1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
//! This crate wraps `tokio-pty-process` in order to provide a simpler API as
//! a single stream object.
//!
//! # Overview
//!
//! When you need to interact with an interactive program as part of an
//! asynchronous application, it can be tricky to figure out the way to
//! structure the different parts that are required. This crate simplifies the
//! API down to just providing the input via an `AsyncRead` object, and then
//! getting updates about what the program is doing via results generated by a
//! stream.
//!
//! # Synopsis
//!
//! This is an example of how to run an interactive program and have it behave
//! identically to running it in the shell. Note that we have to use our own
//! `Stdin` implementation here because `tokio::io::stdin()` is actually
//! blocking, and so polling it as part of an interactive application doesn't
//! work correctly. The implementation of `Stdin` is elided here, but you can
//! see the full implementation in `examples/shell.rs` in the repository.
//!
//! ```no_run
//! # use futures::future::Future as _;
//! # use futures::stream::Stream as _;
//! # use std::io::{Read as _, Write as _};
//! #
//! let mut argv = std::env::args();
//! argv.next().unwrap();
//! let cmd = argv.next().unwrap();
//! let args: Vec<_> = argv.collect();
//!
//! let process =
//! tokio_pty_process_stream::Process::new(&cmd, &args, Stdin::new());
//! let process = tokio_pty_process_stream::ResizingProcess::new(process);
//!
//! let _raw = crossterm::RawScreen::into_raw_mode().unwrap();
//! tokio::run(
//! process
//! .for_each(|ev| {
//! match ev {
//! tokio_pty_process_stream::Event::CommandStart {
//! ..
//! } => {}
//! tokio_pty_process_stream::Event::Output { data } => {
//! let stdout = std::io::stdout();
//! let mut stdout = stdout.lock();
//! stdout.write_all(&data).unwrap();
//! stdout.flush().unwrap();
//! }
//! tokio_pty_process_stream::Event::CommandExit {
//! ..
//! } => {}
//! tokio_pty_process_stream::Event::Resize { .. } => {}
//! }
//! futures::future::ok(())
//! })
//! .map_err(|e| panic!(e)),
//! );
//! #
//! # struct EventedStdin;
//! #
//! # const STDIN: i32 = 0;
//! #
//! # impl std::io::Read for EventedStdin {
//! # fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
//! # let stdin = std::io::stdin();
//! # let mut stdin = stdin.lock();
//! # stdin.read(buf)
//! # }
//! # }
//! #
//! # impl mio::Evented for EventedStdin {
//! # fn register(
//! # &self,
//! # poll: &mio::Poll,
//! # token: mio::Token,
//! # interest: mio::Ready,
//! # opts: mio::PollOpt,
//! # ) -> std::io::Result<()> {
//! # let fd = STDIN as std::os::unix::io::RawFd;
//! # let eventedfd = mio::unix::EventedFd(&fd);
//! # eventedfd.register(poll, token, interest, opts)
//! # }
//! #
//! # fn reregister(
//! # &self,
//! # poll: &mio::Poll,
//! # token: mio::Token,
//! # interest: mio::Ready,
//! # opts: mio::PollOpt,
//! # ) -> std::io::Result<()> {
//! # let fd = STDIN as std::os::unix::io::RawFd;
//! # let eventedfd = mio::unix::EventedFd(&fd);
//! # eventedfd.reregister(poll, token, interest, opts)
//! # }
//! #
//! # fn deregister(&self, poll: &mio::Poll) -> std::io::Result<()> {
//! # let fd = STDIN as std::os::unix::io::RawFd;
//! # let eventedfd = mio::unix::EventedFd(&fd);
//! # eventedfd.deregister(poll)
//! # }
//! # }
//! #
//! # pub struct Stdin {
//! # input: tokio::reactor::PollEvented2<EventedStdin>,
//! # }
//! #
//! # impl Stdin {
//! # pub fn new() -> Self {
//! # Default::default()
//! # }
//! # }
//! #
//! # impl Default for Stdin {
//! # fn default() -> Self {
//! # Self {
//! # input: tokio::reactor::PollEvented2::new(EventedStdin),
//! # }
//! # }
//! # }
//! #
//! # impl std::io::Read for Stdin {
//! # fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
//! # self.input.read(buf)
//! # }
//! # }
//! #
//! # impl tokio::io::AsyncRead for Stdin {
//! # fn poll_read(
//! # &mut self,
//! # buf: &mut [u8],
//! # ) -> std::result::Result<futures::Async<usize>, tokio::io::Error> {
//! # let ready = mio::Ready::readable();
//! # futures::try_ready!(self.input.poll_read_ready(ready));
//! #
//! # let res = self.read(buf)?;
//! # self.input.clear_read_ready(ready)?;
//! # Ok(futures::Async::Ready(res))
//! # }
//! # }
//! ```
// XXX this is broken with ale
// #![warn(clippy::cargo)]
#![warn(clippy::pedantic)]
#![warn(clippy::nursery)]
#![allow(clippy::missing_const_for_fn)]
#![allow(clippy::multiple_crate_versions)]
#![allow(clippy::type_complexity)]
mod error;
pub use error::Error;
mod process;
pub use process::Event;
pub use process::Process;
mod resize;
pub use resize::ResizingProcess;
|
