rust/src/libcore/run.rs

511 lines
14 KiB
Rust
Raw Normal View History

// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! Process spawning
use cast;
use io;
2012-09-04 13:12:17 -05:00
use io::ReaderUtil;
use libc;
use libc::{pid_t, c_void, c_int};
use pipes::{stream, SharedChan, GenericChan, GenericPort};
use option::{Some, None};
use os;
use prelude::*;
use ptr;
use run;
use str;
use task;
use vec;
#[abi = "cdecl"]
extern mod rustrt {
unsafe fn rust_run_program(argv: **libc::c_char, envp: *c_void,
dir: *libc::c_char,
in_fd: c_int, out_fd: c_int, err_fd: c_int)
-> pid_t;
}
/// A value representing a child process
pub trait Program {
/// Returns the process id of the program
fn get_id(&mut self) -> pid_t;
2011-10-26 18:24:31 -05:00
/// Returns an io::writer that can be used to write to stdin
fn input(&mut self) -> io::Writer;
2011-10-26 18:24:31 -05:00
/// Returns an io::reader that can be used to read from stdout
fn output(&mut self) -> io::Reader;
2011-10-26 18:24:31 -05:00
/// Returns an io::reader that can be used to read from stderr
fn err(&mut self) -> io::Reader;
2011-10-26 18:24:31 -05:00
/// Closes the handle to the child processes standard input
fn close_input(&mut self);
2011-10-26 18:24:31 -05:00
/**
* Waits for the child process to terminate. Closes the handle
* to stdin if necessary.
*/
fn finish(&mut self) -> int;
2011-10-26 18:24:31 -05:00
/// Closes open handles
fn destroy(&mut self);
2012-01-11 06:27:46 -06:00
}
2011-10-26 18:24:31 -05:00
/**
* Run a program, providing stdin, stdout and stderr handles
*
* # Arguments
*
* * prog - The path to an executable
* * args - Vector of arguments to pass to the child process
* * env - optional env-modification for child
* * dir - optional dir to run child in (default current dir)
* * in_fd - A file descriptor for the child to use as std input
* * out_fd - A file descriptor for the child to use as std output
* * err_fd - A file descriptor for the child to use as std error
*
* # Return value
*
* The process id of the spawned process
*/
pub fn spawn_process(prog: &str, args: &[~str],
2012-08-20 14:23:37 -05:00
env: &Option<~[(~str,~str)]>,
dir: &Option<~str>,
in_fd: c_int, out_fd: c_int, err_fd: c_int)
-> pid_t {
unsafe {
do with_argv(prog, args) |argv| {
do with_envp(env) |envp| {
do with_dirp(dir) |dirp| {
rustrt::rust_run_program(argv, envp, dirp,
in_fd, out_fd, err_fd)
}
}
}
}
}
2012-08-14 14:11:15 -05:00
fn with_argv<T>(prog: &str, args: &[~str],
cb: fn(**libc::c_char) -> T) -> T {
2012-06-30 18:19:07 -05:00
let mut argptrs = str::as_c_str(prog, |b| ~[b]);
let mut tmps = ~[];
for vec::each(args) |arg| {
let t = @copy *arg;
tmps.push(t);
argptrs.push_all(str::as_c_str(*t, |b| ~[b]));
}
argptrs.push(ptr::null());
vec::as_imm_buf(argptrs, |buf, _len| cb(buf))
}
#[cfg(unix)]
2012-08-20 14:23:37 -05:00
fn with_envp<T>(env: &Option<~[(~str,~str)]>,
cb: fn(*c_void) -> T) -> T {
// On posixy systems we can pass a char** for envp, which is
// a null-terminated array of "k=v\n" strings.
2012-08-14 14:11:15 -05:00
match *env {
2012-09-28 15:00:07 -05:00
Some(ref es) if !vec::is_empty(*es) => {
let mut tmps = ~[];
let mut ptrs = ~[];
2012-09-28 15:00:07 -05:00
for vec::each(*es) |e| {
let (k,v) = copy *e;
2012-08-22 19:24:52 -05:00
let t = @(fmt!("%s=%s", k, v));
tmps.push(t);
ptrs.push_all(str::as_c_str(*t, |b| ~[b]));
}
ptrs.push(ptr::null());
vec::as_imm_buf(ptrs, |p, _len|
2012-09-18 19:34:08 -05:00
unsafe { cb(::cast::reinterpret_cast(&p)) }
2012-06-30 18:19:07 -05:00
)
}
2012-08-03 21:59:04 -05:00
_ => cb(ptr::null())
}
}
#[cfg(windows)]
2012-08-20 14:23:37 -05:00
fn with_envp<T>(env: &Option<~[(~str,~str)]>,
cb: fn(*c_void) -> T) -> T {
// On win32 we pass an "environment block" which is not a char**, but
// rather a concatenation of null-terminated k=v\0 sequences, with a final
// \0 to terminate.
unsafe {
2012-08-14 17:58:21 -05:00
match *env {
Some(ref es) if !vec::is_empty(*es) => {
let mut blk : ~[u8] = ~[];
for vec::each(*es) |e| {
2012-12-14 16:26:57 -06:00
let (k,v) = copy *e;
2012-08-22 19:24:52 -05:00
let t = fmt!("%s=%s", k, v);
2012-09-19 10:25:49 -05:00
let mut v : ~[u8] = ::cast::reinterpret_cast(&t);
blk += v;
2012-09-19 10:25:49 -05:00
::cast::forget(v);
}
blk += ~[0_u8];
2012-09-19 10:25:49 -05:00
vec::as_imm_buf(blk, |p, _len| cb(::cast::reinterpret_cast(&p)))
}
2012-08-03 21:59:04 -05:00
_ => cb(ptr::null())
}
}
}
2012-08-20 14:23:37 -05:00
fn with_dirp<T>(d: &Option<~str>,
cb: fn(*libc::c_char) -> T) -> T {
2012-08-14 14:11:15 -05:00
match *d {
2012-09-28 15:00:07 -05:00
Some(ref dir) => str::as_c_str(*dir, cb),
2012-08-20 14:23:37 -05:00
None => cb(ptr::null())
}
2011-07-18 23:07:33 -05:00
}
/**
* Spawns a process and waits for it to terminate
*
* # Arguments
*
* * prog - The path to an executable
* * args - Vector of arguments to pass to the child process
*
* # Return value
*
* The process id
*/
pub fn run_program(prog: &str, args: &[~str]) -> int {
2012-08-20 14:23:37 -05:00
let pid = spawn_process(prog, args, &None, &None,
0i32, 0i32, 0i32);
if pid == -1 as pid_t { fail!(); }
2012-08-01 19:30:05 -05:00
return waitpid(pid);
}
/**
* Spawns a process and returns a program
*
* The returned value is a boxed class containing a <program> object that can
* be used for sending and receiving data over the standard file descriptors.
* The class will ensure that file descriptors are closed properly.
*
* # Arguments
*
* * prog - The path to an executable
* * args - Vector of arguments to pass to the child process
*
* # Return value
*
* A class with a <program> field
*/
pub fn start_program(prog: &str, args: &[~str]) -> Program {
let pipe_input = os::pipe();
let pipe_output = os::pipe();
let pipe_err = os::pipe();
let pid =
spawn_process(prog, args, &None, &None,
pipe_input.in, pipe_output.out,
pipe_err.out);
unsafe {
if pid == -1 as pid_t { fail!(); }
libc::close(pipe_input.in);
libc::close(pipe_output.out);
libc::close(pipe_err.out);
}
2011-07-18 23:07:33 -05:00
struct ProgRepr {
pid: pid_t,
in_fd: c_int,
out_file: *libc::FILE,
err_file: *libc::FILE,
finished: bool,
}
fn close_repr_input(r: &mut ProgRepr) {
let invalid_fd = -1i32;
if r.in_fd != invalid_fd {
unsafe {
libc::close(r.in_fd);
}
r.in_fd = invalid_fd;
}
}
fn finish_repr(r: &mut ProgRepr) -> int {
if r.finished { return 0; }
r.finished = true;
close_repr_input(&mut *r);
return waitpid(r.pid);
}
fn destroy_repr(r: &mut ProgRepr) {
unsafe {
finish_repr(&mut *r);
libc::fclose(r.out_file);
libc::fclose(r.err_file);
2012-01-11 06:27:46 -06:00
}
}
struct ProgRes {
r: ProgRepr,
drop {
unsafe {
2013-02-14 20:17:56 -06:00
// FIXME #4943: This is bad.
destroy_repr(cast::transmute(&self.r));
}
}
}
2012-01-11 06:27:46 -06:00
fn ProgRes(r: ProgRepr) -> ProgRes {
ProgRes {
2013-02-15 02:51:28 -06:00
r: r
2012-09-04 17:23:28 -05:00
}
}
2012-09-04 17:23:28 -05:00
impl Program for ProgRes {
fn get_id(&mut self) -> pid_t { return self.r.pid; }
fn input(&mut self) -> io::Writer {
io::fd_writer(self.r.in_fd, false)
}
fn output(&mut self) -> io::Reader {
io::FILE_reader(self.r.out_file, false)
}
fn err(&mut self) -> io::Reader {
io::FILE_reader(self.r.err_file, false)
}
fn close_input(&mut self) { close_repr_input(&mut self.r); }
fn finish(&mut self) -> int { finish_repr(&mut self.r) }
fn destroy(&mut self) { destroy_repr(&mut self.r); }
}
let mut repr = ProgRepr {
pid: pid,
in_fd: pipe_input.out,
out_file: os::fdopen(pipe_output.in),
err_file: os::fdopen(pipe_err.in),
finished: false,
};
ProgRes(repr) as Program
}
2012-08-14 15:38:35 -05:00
fn read_all(rd: io::Reader) -> ~str {
let buf = io::with_bytes_writer(|wr| {
2013-02-11 21:50:35 -06:00
let mut bytes = [0, ..4096];
while !rd.eof() {
let nread = rd.read(bytes, bytes.len());
wr.write(bytes.view(0, nread));
}
});
str::from_bytes(buf)
2011-07-28 23:15:56 -05:00
}
pub struct ProgramOutput {status: int, out: ~str, err: ~str}
/**
* Spawns a process, waits for it to exit, and returns the exit code, and
* contents of stdout and stderr.
*
* # Arguments
*
* * prog - The path to an executable
* * args - Vector of arguments to pass to the child process
*
* # Return value
*
* A record, {status: int, out: str, err: str} containing the exit code,
* the contents of stdout and the contents of stderr.
*/
pub fn program_output(prog: &str, args: &[~str]) -> ProgramOutput {
unsafe {
let pipe_in = os::pipe();
let pipe_out = os::pipe();
let pipe_err = os::pipe();
let pid = spawn_process(prog, args, &None, &None,
pipe_in.in, pipe_out.out, pipe_err.out);
os::close(pipe_in.in);
os::close(pipe_out.out);
os::close(pipe_err.out);
if pid == -1i32 {
os::close(pipe_in.out);
os::close(pipe_out.in);
os::close(pipe_err.in);
fail!();
}
os::close(pipe_in.out);
// Spawn two entire schedulers to read both stdout and sterr
// in parallel so we don't deadlock while blocking on one
// or the other. FIXME (#2625): Surely there's a much more
// clever way to do this.
2013-01-22 14:38:08 -06:00
let (p, ch) = stream();
let ch = SharedChan(ch);
let ch_clone = ch.clone();
do task::spawn_sched(task::SingleThreaded) {
let errput = readclose(pipe_err.in);
2013-02-15 02:51:28 -06:00
ch.send((2, errput));
};
do task::spawn_sched(task::SingleThreaded) {
let output = readclose(pipe_out.in);
2013-02-15 02:51:28 -06:00
ch_clone.send((1, output));
};
let status = run::waitpid(pid);
let mut errs = ~"";
let mut outs = ~"";
let mut count = 2;
while count > 0 {
2013-01-22 14:38:08 -06:00
let stream = p.recv();
match stream {
(1, copy s) => {
2013-02-15 02:51:28 -06:00
outs = s;
}
(2, copy s) => {
2013-02-15 02:51:28 -06:00
errs = s;
}
(n, _) => {
fail!(fmt!("program_output received an unexpected file \
number: %u", n));
}
};
count -= 1;
};
return ProgramOutput {status: status,
2013-02-15 02:51:28 -06:00
out: outs,
err: errs};
}
}
pub fn writeclose(fd: c_int, s: ~str) {
use io::WriterUtil;
2012-08-22 19:24:52 -05:00
error!("writeclose %d, %s", fd as int, s);
let writer = io::fd_writer(fd, false);
writer.write_str(s);
os::close(fd);
}
pub fn readclose(fd: c_int) -> ~str {
unsafe {
let file = os::fdopen(fd);
let reader = io::FILE_reader(file, false);
let buf = io::with_bytes_writer(|writer| {
2013-02-11 21:50:35 -06:00
let mut bytes = [0, ..4096];
while !reader.eof() {
let nread = reader.read(bytes, bytes.len());
writer.write(bytes.view(0, nread));
}
});
os::fclose(file);
str::from_bytes(buf)
}
}
/// Waits for a process to exit and returns the exit code
pub fn waitpid(pid: pid_t) -> int {
2012-08-01 19:30:05 -05:00
return waitpid_os(pid);
#[cfg(windows)]
fn waitpid_os(pid: pid_t) -> int {
os::waitpid(pid) as int
}
#[cfg(unix)]
2011-11-15 00:29:40 -06:00
fn waitpid_os(pid: pid_t) -> int {
2011-10-26 18:24:31 -05:00
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
2011-11-15 00:29:40 -06:00
fn WIFEXITED(status: i32) -> bool {
(status & 0xffi32) == 0i32
2011-10-26 18:24:31 -05:00
}
2011-10-26 18:24:31 -05:00
#[cfg(target_os = "macos")]
2011-12-30 02:18:55 -06:00
#[cfg(target_os = "freebsd")]
2011-11-15 00:29:40 -06:00
fn WIFEXITED(status: i32) -> bool {
(status & 0x7fi32) == 0i32
2011-10-26 18:24:31 -05:00
}
#[cfg(target_os = "linux")]
#[cfg(target_os = "android")]
2011-11-15 00:29:40 -06:00
fn WEXITSTATUS(status: i32) -> i32 {
(status >> 8i32) & 0xffi32
2011-10-26 18:24:31 -05:00
}
#[cfg(target_os = "macos")]
2011-12-30 02:18:55 -06:00
#[cfg(target_os = "freebsd")]
2011-11-15 00:29:40 -06:00
fn WEXITSTATUS(status: i32) -> i32 {
status >> 8i32
2011-10-26 18:24:31 -05:00
}
let status = os::waitpid(pid);
2012-08-01 19:30:05 -05:00
return if WIFEXITED(status) {
2011-11-15 00:29:40 -06:00
WEXITSTATUS(status) as int
2011-10-26 18:24:31 -05:00
} else {
1
};
}
}
2012-01-17 21:05:07 -06:00
#[cfg(test)]
mod tests {
use debug;
use io::WriterUtil;
use option::{None, Some};
use os;
use run::{readclose, writeclose};
use run;
2012-01-17 21:05:07 -06:00
// Regression test for memory leaks
#[ignore(cfg(windows))] // FIXME (#2626)
pub fn test_leaks() {
2012-08-14 14:11:15 -05:00
run::run_program("echo", []);
run::start_program("echo", []);
run::program_output("echo", []);
2012-01-17 21:05:07 -06:00
}
#[test]
2012-09-28 15:00:07 -05:00
#[allow(non_implicitly_copyable_typarams)]
pub fn test_pipes() {
2012-01-17 21:05:07 -06:00
let pipe_in = os::pipe();
let pipe_out = os::pipe();
let pipe_err = os::pipe();
let pid =
run::spawn_process(
2012-08-20 14:23:37 -05:00
"cat", [], &None, &None,
pipe_in.in, pipe_out.out, pipe_err.out);
2012-01-17 21:05:07 -06:00
os::close(pipe_in.in);
os::close(pipe_out.out);
os::close(pipe_err.out);
if pid == -1i32 { fail!(); }
let expected = ~"test";
2012-09-28 15:00:07 -05:00
writeclose(pipe_in.out, copy expected);
2012-01-17 21:05:07 -06:00
let actual = readclose(pipe_out.in);
readclose(pipe_err.in);
os::waitpid(pid);
log(debug, copy expected);
log(debug, copy actual);
2012-01-17 21:05:07 -06:00
assert (expected == actual);
}
#[test]
pub fn waitpid() {
2012-08-14 14:11:15 -05:00
let pid = run::spawn_process("false", [],
2012-08-20 14:23:37 -05:00
&None, &None,
0i32, 0i32, 0i32);
2012-01-17 21:05:07 -06:00
let status = run::waitpid(pid);
assert status == 1;
}
}
// Local Variables:
// mode: rust
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// End: