Merge branch 'master' into new_api

Author: zhiburt

CHANGELOG.md

@@ -3,10 +3,11 @@
 All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
-## [0.4.0] 2018-03-17
+## [0.4.0] 2020-05-25
 
 ### Changed
 
+- PtySession now works with any stream type, e.g. also tcp streams are supported now (thanks, thomasantony)
 - breaking: PtyBashSession was renamed and generalized into
   PtyReplSession to allow an interface for other REPLs 
 - better error messages in case of timeout to help debug when you expect
@@ -48,4 +49,4 @@ All `exp_*` methods now also return the yet unread string and/or the matched str
 ### Fixed
 
 - each execution of rexpect left a temporary file in /tmp/ this is now no longer the case
-- try_read was blocking when there was no char ready (!) -> fixed
+- try_read was blocking when there was no char ready (!) -> fixed

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 description = "Interact with unix processes/bash the same way as pexpect or Don libes expect does"
 name        = "rexpect"
-version     = "0.3.0"
+version     = "0.4.0"
 authors     = ["Philipp Keller <[email protected]>"]
 edition     = "2018"
 repository  = "https://github.com/philippkeller/rexpect"
@@ -20,4 +20,4 @@ error-chain = "0.12"
 tempfile = "3"
 
 [badges]
-travis-ci = { repository = "philippkeller/rexpect" }
+travis-ci = { repository = "philippkeller/rexpect" }

Cargo.toml

@@ -22,7 +22,7 @@ Add this to your `Cargo.toml`
 
 ```toml
 [dependencies]
-rexpect = "0.3"
+rexpect = "0.4"
 ```
 
 Simple example for interacting via ftp:
@@ -148,9 +148,6 @@ I'm happy to receive PRs or also Issue requests of course.
 The tests cover most of the aspects and it should run out of the box for
 rust stable, beta and nightly on both Linux or Mac.
 
-That said, I don't know of too many people using it yet, so use this
-with caution.  
-
 ## Design decisions
 
 - use error handling of [error-chain](https://github.com/brson/error-chain)

README.md

@@ -2,7 +2,6 @@ extern crate rexpect;
 use rexpect::spawn_bash;
 use rexpect::errors::*;
 
-
 fn run() -> Result<()> {
     let mut p = spawn_bash(Some(1000))?;
     p.execute("ping 8.8.8.8", "bytes")?;

examples/bash.rs

@@ -0,0 +1,16 @@
+use rexpect::spawn_stream;
+use std::net::TcpStream;
+use std::error::Error;
+
+fn main() -> Result<(), Box<dyn Error>>
+{
+    let tcp = TcpStream::connect("www.google.com:80")?;
+    let tcp_w = tcp.try_clone()?;
+    let mut session = spawn_stream(tcp, tcp_w, Some(2000));
+    session.send_line("GET / HTTP/1.1")?;
+    session.send_line("Host: www.google.com")?;
+    session.send_line("Accept-Language: fr")?;
+    session.send_line("")?;
+    session.exp_string("HTTP/1.1 200 OK")?;
+    Ok(())
+}

examples/tcp.rs

@@ -82,21 +82,21 @@ pub mod process;
 pub mod session;
 pub mod reader;
 
-pub use session::{spawn, spawn_bash, spawn_python};
+pub use session::{spawn, spawn_bash, spawn_python, spawn_stream};
+pub use reader::{Until};
 
 pub mod errors {
     use std::time;
-    use crate::process::wait;
     // Create the Error, ErrorKind, ResultExt, and Result types
     error_chain::error_chain!{
         errors {
-            EOF(expected:String, got:String, exit_code:Option<wait::WaitStatus>) {
+            EOF(expected:String, got:String, exit_code:Option<String>) {
                 description("End of filestream (usually stdout) occurred, most probably\
                              because the process terminated")
                 display("EOF (End of File): Expected {} but got EOF after reading \"{}\", \
                              process terminated with {:?}", expected, got,
-                             exit_code.map(|status| format!("{:?}", status))
-                             .unwrap_or("unknown".to_string()))
+                             exit_code.as_ref()
+                             .unwrap_or(& "unknown".to_string()))
             }
             BrokenPipe {
                 description("The pipe to the process is broken. Most probably because\
@@ -109,6 +109,10 @@ pub mod errors {
                         expected, got, (timeout.as_secs() * 1000) as u32
                         + timeout.subsec_nanos() / 1_000_000)
             }
+            EmptyProgramName {
+                description("The provided program name is empty.")
+                display("EmptyProgramName")
+            }
         }
     }
 }

src/lib.rs

@@ -15,7 +15,6 @@ use nix::libc::{STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
 pub use nix::sys::{wait, signal};
 use crate::errors::*; // load error-chain
 
-
 /// Start a process in a forked tty so you can interact with it the same as you would
 /// within a terminal
 ///
@@ -71,7 +70,6 @@ use nix::pty::ptsname_r;
 /// based on https://blog.tarq.io/ptsname-on-osx-with-rust/
 fn ptsname_r(fd: &PtyMaster) -> nix::Result<String> {
     use std::ffi::CStr;
-    use std::os::unix::io::AsRawFd;
     use nix::libc::{ioctl, TIOCPTYGNAME};
 
     // the buffer size on OSX is 128, defined by sys/ttycom.h
@@ -152,21 +150,21 @@ impl PtyProcess {
     ///
     /// This method runs waitpid on the process.
     /// This means: If you ran `exit()` before or `status()` this method will
-    /// return an Error
+    /// return `None`
     ///
     /// # Example
     /// ```rust,no_run
     ///
     /// # extern crate rexpect;
-    /// use rexpect::process;
+    /// use rexpect::process::{self, wait::WaitStatus};
     /// use std::process::Command;
     ///
     /// # fn main() {
-    ///     let cmd = Command::new("/path/to/myprog");
-    ///     let process = process::PtyProcess::new(cmd).expect("could not execute myprog");
-    ///     while process.status().unwrap() == process::wait::WaitStatus::StillAlive {
-    ///         // do something
-    ///     }
+    /// let cmd = Command::new("/path/to/myprog");
+    /// let process = process::PtyProcess::new(cmd).expect("could not execute myprog");
+    /// while let Some(WaitStatus::StillAlive) = process.status() {
+    ///     // do something
+    /// }
     /// # }
     /// ```
     ///

src/process.rs

@@ -10,35 +10,19 @@ use std::ops::{Deref, DerefMut};
 use std::process::Command;
 use tempfile;
 
-/// Interact with a process with read/write/signals, etc.
-#[allow(dead_code)]
-pub struct PtySession {
-    pub process: PtyProcess,
-    pub writer: LineWriter<File>,
+pub struct StreamSession<W: Write> {
+    pub writer: LineWriter<W>,
     pub reader: NBReader,
-    pub commandname: String, // only for debugging purposes now
 }
 
-/// Start a process in a tty session, write and read from it
-///
-/// # Example
-///
-/// ```
-///
-/// use rexpect::spawn;
-/// # use rexpect::errors::*;
-///
-/// # fn main() {
-///     # || -> Result<()> {
-/// let mut s = spawn("cat", Some(1000))?;
-/// s.send_line("hello, polly!")?;
-/// let line = s.read_line()?;
-/// assert_eq!("hello, polly!", line);
-///         # Ok(())
-///     # }().expect("test failed");
-/// # }
-/// ```
-impl PtySession {
+impl<W: Write> StreamSession<W> {
+    pub fn new<R: Read + Send + 'static>(reader: R, writer: W, timeout_ms: Option<u64>) -> Self {
+        Self {
+            writer: LineWriter::new(writer),
+            reader: NBReader::new(reader, timeout_ms),
+        }
+    }
+
     /// sends string and a newline to process
     ///
     /// this is guaranteed to be flushed to the process
@@ -123,6 +107,11 @@ impl PtySession {
         self.reader.try_read()
     }
 
+    // wrapper around reader::read_until to give more context for errors
+    fn exp(&mut self, needle: &ReadUntil) -> Result<(String, String)> {
+        self.reader.read_until(needle)
+    }
+
     /// Wait until we see EOF (i.e. child process has terminated)
     /// Return all the yet unread output
     pub fn exp_eof(&mut self) -> Result<String> {
@@ -154,6 +143,61 @@ impl PtySession {
         self.exp(&Str(needle.to_string()))
     }
 }
+/// Interact with a process with read/write/signals, etc.
+#[allow(dead_code)]
+pub struct PtySession {
+    pub process: PtyProcess,
+    pub stream: StreamSession<File>,
+    pub commandname: String, // only for debugging purposes now
+}
+
+
+// make StreamSession's methods available directly
+impl Deref for PtySession {
+    type Target = StreamSession<File>;
+    fn deref(&self) -> &StreamSession<File> {
+        &self.stream
+    }
+}
+
+impl DerefMut for PtySession {
+    fn deref_mut(&mut self) -> &mut StreamSession<File> {
+        &mut self.stream
+    }
+}
+
+/// Start a process in a tty session, write and read from it
+///
+/// # Example
+///
+/// ```
+///
+/// use rexpect::spawn;
+/// # use rexpect::errors::*;
+///
+/// # fn main() {
+///     # || -> Result<()> {
+/// let mut s = spawn("cat", Some(1000))?;
+/// s.send_line("hello, polly!")?;
+/// let line = s.read_line()?;
+/// assert_eq!("hello, polly!", line);
+///         # Ok(())
+///     # }().expect("test failed");
+/// # }
+/// ```
+impl PtySession {
+    fn new(process: PtyProcess, timeout_ms: Option<u64>, commandname: String) -> Result<Self> {
+        
+        let f = process.get_file_handle();
+        let reader = f.try_clone().chain_err(|| "couldn't open write stream")?;
+        let stream = StreamSession::new(reader, f, timeout_ms);
+        Ok(Self {
+            process,
+            stream,
+            commandname: commandname,
+        })
+    }
+}
 
 /// Turn e.g. "prog arg1 arg2" into ["prog", "arg1", "arg2"]
 /// Also takes care of single and double quotes
@@ -180,15 +224,14 @@ fn tokenize_command(program: &str) -> Vec<String> {
 ///   error message indicating where it stopped.
 ///   For automation 30'000 (30s, the default in pexpect) is a good value.
 pub fn spawn(program: &str, timeout_ms: Option<u64>) -> Result<PtySession> {
-    let command = if program.find(" ").is_some() {
-        let mut parts = tokenize_command(program);
-        let mut cmd = Command::new(&parts[0].to_string());
-        parts.remove(0);
-        cmd.args(parts);
-        cmd
-    } else {
-        Command::new(program)
-    };
+    if program.is_empty() {
+        return Err(ErrorKind::EmptyProgramName.into());
+    }
+
+    let mut parts = tokenize_command(program);
+    let prog = parts.remove(0);
+    let mut command = Command::new(prog);
+    command.args(parts);
     spawn_command(command, timeout_ms)
 }
 
@@ -395,6 +438,11 @@ pub fn spawn_python(timeout: Option<u64>) -> Result<PtyReplSession> {
     })
 }
 
+/// Spawn a REPL from a stream
+pub fn spawn_stream<R: Read + Send + 'static, W: Write>(reader: R, writer: W, timeout_ms: Option<u64>) -> StreamSession<W> {
+    StreamSession::new(reader, writer, timeout_ms)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -497,6 +545,15 @@ mod tests {
             Ok(())
         }()
         .unwrap_or_else(|e| panic!("test_expect_any failed: {}", e));
+
+    #[test]
+    fn test_expect_empty_command_error() {
+        let p = spawn("", Some(1000));
+        match p {
+            Ok(_) => assert!(false, "should raise an error"),
+            Err(Error(ErrorKind::EmptyProgramName, _)) => {}
+            Err(_) => assert!(false, "should raise EmptyProgramName"),
+        }
     }
 
     #[test]