Revert "auto merge of #8645 : alexcrichton/rust/issue-6436-run-non-blocking, r=brson"
This reverts commitb8d1fa3994
, reversing changes made tof22b4b1698
. Conflicts: mk/rt.mk src/libuv
This commit is contained in:
parent
698873e3a8
commit
3c5a43e5b6
|
@ -4,5 +4,5 @@
|
||||||
branch = master
|
branch = master
|
||||||
[submodule "src/libuv"]
|
[submodule "src/libuv"]
|
||||||
path = src/libuv
|
path = src/libuv
|
||||||
url = https://github.com/alexcrichton/libuv.git
|
url = https://github.com/brson/libuv.git
|
||||||
branch = master
|
branch = master
|
||||||
|
|
46
mk/rt.mk
46
mk/rt.mk
|
@ -168,58 +168,36 @@ LIBUV_DEPS := $$(wildcard \
|
||||||
$$(S)src/libuv/*/*/*/*)
|
$$(S)src/libuv/*/*/*/*)
|
||||||
endif
|
endif
|
||||||
|
|
||||||
LIBUV_GYP := $$(S)src/libuv/build/gyp
|
|
||||||
LIBUV_MAKEFILE_$(1)_$(2) := $$(CFG_BUILD_DIR)rt/$(1)/stage$(2)/libuv/Makefile
|
|
||||||
LIBUV_NO_LOAD = run-benchmarks.target.mk run-tests.target.mk \
|
|
||||||
uv_dtrace_header.target.mk uv_dtrace_provider.target.mk
|
|
||||||
|
|
||||||
ifeq ($(OSTYPE_$(1)), linux-androideabi)
|
|
||||||
$$(LIBUV_MAKEFILE_$(1)_$(2)): $$(LIBUV_GYP)
|
|
||||||
(cd $(S)src/libuv/ && \
|
|
||||||
$$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja -DOS=android \
|
|
||||||
-Goutput_dir=$$(@D) --generator-output $$(@D))
|
|
||||||
else
|
|
||||||
$$(LIBUV_MAKEFILE_$(1)_$(2)): $$(LIBUV_GYP)
|
|
||||||
(cd $(S)src/libuv/ && \
|
|
||||||
$$(CFG_PYTHON) ./gyp_uv -f make -Dtarget_arch=$$(LIBUV_ARCH_$(1)) -D ninja \
|
|
||||||
-Goutput_dir=$$(@D) --generator-output $$(@D))
|
|
||||||
endif
|
|
||||||
|
|
||||||
# XXX: Shouldn't need platform-specific conditions here
|
# XXX: Shouldn't need platform-specific conditions here
|
||||||
ifdef CFG_WINDOWSY_$(1)
|
ifdef CFG_WINDOWSY_$(1)
|
||||||
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
|
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
|
||||||
$$(Q)rm -f $$(S)src/libuv/libuv.a
|
$$(Q)$$(MAKE) -C $$(S)src/libuv/ \
|
||||||
$$(Q)$$(MAKE) -C $$(S)src/libuv -f Makefile.mingw \
|
builddir_name="$$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/libuv" \
|
||||||
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
|
OS=mingw \
|
||||||
AR="$$(AR_$(1))" \
|
|
||||||
V=$$(VERBOSE)
|
V=$$(VERBOSE)
|
||||||
$$(Q)cp $$(S)src/libuv/libuv.a $$@
|
|
||||||
else ifeq ($(OSTYPE_$(1)), linux-androideabi)
|
else ifeq ($(OSTYPE_$(1)), linux-androideabi)
|
||||||
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS) $$(LIBUV_MAKEFILE_$(1)_$(2))
|
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
|
||||||
$$(Q)$$(MAKE) -C $$(@D) \
|
$$(Q)$$(MAKE) -C $$(S)src/libuv/ \
|
||||||
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
|
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
|
||||||
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
|
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
|
||||||
CC="$$(CC_$(1))" \
|
CC="$$(CC_$(1))" \
|
||||||
CXX="$$(CXX_$(1))" \
|
CXX="$$(CXX_$(1))" \
|
||||||
LINK="$$(CXX_$(1))" \
|
LINK="$$(CXX_$(1))" \
|
||||||
AR="$$(AR_$(1))" \
|
AR="$$(AR_$(1))" \
|
||||||
host=android OS=linux \
|
|
||||||
PLATFORM=android \
|
PLATFORM=android \
|
||||||
builddir="." \
|
|
||||||
BUILDTYPE=Release \
|
BUILDTYPE=Release \
|
||||||
NO_LOAD="$$(LIBUV_NO_LOAD)" \
|
builddir_name="$$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/libuv" \
|
||||||
|
host=android OS=linux \
|
||||||
V=$$(VERBOSE)
|
V=$$(VERBOSE)
|
||||||
else
|
else
|
||||||
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS) $$(LIBUV_MAKEFILE_$(1)_$(2))
|
$$(LIBUV_LIB_$(1)_$(2)): $$(LIBUV_DEPS)
|
||||||
$$(Q)$$(MAKE) -C $$(@D) \
|
$$(Q)$$(MAKE) -C $$(S)src/libuv/ \
|
||||||
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
|
CFLAGS="$$(CFG_GCCISH_CFLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1))) $$(SNAP_DEFINES)" \
|
||||||
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
|
LDFLAGS="$$(CFG_GCCISH_LINK_FLAGS) $$(LIBUV_FLAGS_$$(HOST_$(1)))" \
|
||||||
CC="$$(CC_$(1))" \
|
CC="$$(CC_$(1))" \
|
||||||
CXX="$$(CXX_$(1))" \
|
CXX="$$(CXX_$(1))" \
|
||||||
AR="$$(AR_$(1))" \
|
AR="$$(AR_$(1))" \
|
||||||
builddir="." \
|
builddir_name="$$(CFG_BUILD_DIR)/rt/$(1)/stage$(2)/libuv" \
|
||||||
BUILDTYPE=Release \
|
|
||||||
NO_LOAD="$$(LIBUV_NO_LOAD)" \
|
|
||||||
V=$$(VERBOSE)
|
V=$$(VERBOSE)
|
||||||
endif
|
endif
|
||||||
|
|
||||||
|
@ -283,7 +261,3 @@ endef
|
||||||
$(foreach stage,$(STAGES), \
|
$(foreach stage,$(STAGES), \
|
||||||
$(foreach target,$(CFG_TARGET_TRIPLES), \
|
$(foreach target,$(CFG_TARGET_TRIPLES), \
|
||||||
$(eval $(call DEF_RUNTIME_TARGETS,$(target),$(stage)))))
|
$(eval $(call DEF_RUNTIME_TARGETS,$(target),$(stage)))))
|
||||||
|
|
||||||
$(LIBUV_GYP):
|
|
||||||
mkdir -p $(S)src/libuv/build
|
|
||||||
git clone https://git.chromium.org/external/gyp.git $(S)src/libuv/build/gyp
|
|
||||||
|
|
|
@ -54,10 +54,10 @@ pub fn run(lib_path: &str,
|
||||||
in_fd: None,
|
in_fd: None,
|
||||||
out_fd: None,
|
out_fd: None,
|
||||||
err_fd: None
|
err_fd: None
|
||||||
}).unwrap();
|
});
|
||||||
|
|
||||||
for input in input.iter() {
|
for input in input.iter() {
|
||||||
proc.input().write(input.as_bytes());
|
proc.input().write_str(*input);
|
||||||
}
|
}
|
||||||
let output = proc.finish_with_output();
|
let output = proc.finish_with_output();
|
||||||
|
|
||||||
|
|
|
@ -20,16 +20,41 @@ use procsrv;
|
||||||
use util;
|
use util;
|
||||||
use util::logv;
|
use util::logv;
|
||||||
|
|
||||||
|
use std::cell::Cell;
|
||||||
use std::io;
|
use std::io;
|
||||||
use std::os;
|
use std::os;
|
||||||
use std::str;
|
use std::str;
|
||||||
|
use std::task::{spawn_sched, SingleThreaded};
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
use std::unstable::running_on_valgrind;
|
||||||
|
|
||||||
use extra::test::MetricMap;
|
use extra::test::MetricMap;
|
||||||
|
|
||||||
pub fn run(config: config, testfile: ~str) {
|
pub fn run(config: config, testfile: ~str) {
|
||||||
let mut _mm = MetricMap::new();
|
let config = Cell::new(config);
|
||||||
run_metrics(config, testfile, &mut _mm);
|
let testfile = Cell::new(testfile);
|
||||||
|
// FIXME #6436: Creating another thread to run the test because this
|
||||||
|
// is going to call waitpid. The new scheduler has some strange
|
||||||
|
// interaction between the blocking tasks and 'friend' schedulers
|
||||||
|
// that destroys parallelism if we let normal schedulers block.
|
||||||
|
// It should be possible to remove this spawn once std::run is
|
||||||
|
// rewritten to be non-blocking.
|
||||||
|
//
|
||||||
|
// We do _not_ create another thread if we're running on V because
|
||||||
|
// it serializes all threads anyways.
|
||||||
|
if running_on_valgrind() {
|
||||||
|
let config = config.take();
|
||||||
|
let testfile = testfile.take();
|
||||||
|
let mut _mm = MetricMap::new();
|
||||||
|
run_metrics(config, testfile, &mut _mm);
|
||||||
|
} else {
|
||||||
|
do spawn_sched(SingleThreaded) {
|
||||||
|
let config = config.take();
|
||||||
|
let testfile = testfile.take();
|
||||||
|
let mut _mm = MetricMap::new();
|
||||||
|
run_metrics(config, testfile, &mut _mm);
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
|
pub fn run_metrics(config: config, testfile: ~str, mm: &mut MetricMap) {
|
||||||
|
|
|
@ -104,14 +104,14 @@ fn pandoc_writer(
|
||||||
];
|
];
|
||||||
|
|
||||||
do generic_writer |markdown| {
|
do generic_writer |markdown| {
|
||||||
|
use std::io::WriterUtil;
|
||||||
|
|
||||||
debug!("pandoc cmd: %s", pandoc_cmd);
|
debug!("pandoc cmd: %s", pandoc_cmd);
|
||||||
debug!("pandoc args: %s", pandoc_args.connect(" "));
|
debug!("pandoc args: %s", pandoc_args.connect(" "));
|
||||||
|
|
||||||
let proc = run::Process::new(pandoc_cmd, pandoc_args,
|
let mut proc = run::Process::new(pandoc_cmd, pandoc_args, run::ProcessOptions::new());
|
||||||
run::ProcessOptions::new());
|
|
||||||
let mut proc = proc.unwrap();
|
|
||||||
|
|
||||||
proc.input().write(markdown.as_bytes());
|
proc.input().write_str(markdown);
|
||||||
let output = proc.finish_with_output();
|
let output = proc.finish_with_output();
|
||||||
|
|
||||||
debug!("pandoc result: %i", output.status);
|
debug!("pandoc result: %i", output.status);
|
||||||
|
|
|
@ -89,7 +89,7 @@ pub fn git_clone_general(source: &str, target: &Path, v: &Version) -> bool {
|
||||||
|
|
||||||
fn process_output_in_cwd(prog: &str, args: &[~str], cwd: &Path) -> ProcessOutput {
|
fn process_output_in_cwd(prog: &str, args: &[~str], cwd: &Path) -> ProcessOutput {
|
||||||
let mut prog = Process::new(prog, args, ProcessOptions{ dir: Some(cwd)
|
let mut prog = Process::new(prog, args, ProcessOptions{ dir: Some(cwd)
|
||||||
,..ProcessOptions::new()}).unwrap();
|
,..ProcessOptions::new()});
|
||||||
prog.finish_with_output()
|
prog.finish_with_output()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -112,14 +112,13 @@ fn mk_temp_workspace(short_name: &Path, version: &Version) -> Path {
|
||||||
|
|
||||||
fn run_git(args: &[~str], env: Option<~[(~str, ~str)]>, cwd: &Path, err_msg: &str) {
|
fn run_git(args: &[~str], env: Option<~[(~str, ~str)]>, cwd: &Path, err_msg: &str) {
|
||||||
let cwd = (*cwd).clone();
|
let cwd = (*cwd).clone();
|
||||||
let prog = run::Process::new("git", args, run::ProcessOptions {
|
let mut prog = run::Process::new("git", args, run::ProcessOptions {
|
||||||
env: env,
|
env: env,
|
||||||
dir: Some(&cwd),
|
dir: Some(&cwd),
|
||||||
in_fd: None,
|
in_fd: None,
|
||||||
out_fd: None,
|
out_fd: None,
|
||||||
err_fd: None
|
err_fd: None
|
||||||
});
|
});
|
||||||
let mut prog = prog.unwrap();
|
|
||||||
let rslt = prog.finish_with_output();
|
let rslt = prog.finish_with_output();
|
||||||
if rslt.status != 0 {
|
if rslt.status != 0 {
|
||||||
fail!("%s [git returned %?, output = %s, error = %s]", err_msg,
|
fail!("%s [git returned %?, output = %s, error = %s]", err_msg,
|
||||||
|
@ -227,7 +226,7 @@ fn command_line_test_with_env(args: &[~str], cwd: &Path, env: Option<~[(~str, ~s
|
||||||
in_fd: None,
|
in_fd: None,
|
||||||
out_fd: None,
|
out_fd: None,
|
||||||
err_fd: None
|
err_fd: None
|
||||||
}).unwrap();
|
});
|
||||||
let output = prog.finish_with_output();
|
let output = prog.finish_with_output();
|
||||||
debug!("Output from command %s with args %? was %s {%s}[%?]",
|
debug!("Output from command %s with args %? was %s {%s}[%?]",
|
||||||
cmd, args, str::from_bytes(output.output),
|
cmd, args, str::from_bytes(output.output),
|
||||||
|
@ -1028,17 +1027,16 @@ fn test_extern_mod() {
|
||||||
test_sysroot().to_str(),
|
test_sysroot().to_str(),
|
||||||
exec_file.to_str());
|
exec_file.to_str());
|
||||||
|
|
||||||
let prog = run::Process::new(rustc.to_str(), [main_file.to_str(),
|
let mut prog = run::Process::new(rustc.to_str(), [main_file.to_str(),
|
||||||
~"--sysroot", test_sysroot().to_str(),
|
~"--sysroot", test_sysroot().to_str(),
|
||||||
~"-o", exec_file.to_str()],
|
~"-o", exec_file.to_str()],
|
||||||
run::ProcessOptions {
|
run::ProcessOptions {
|
||||||
env: env,
|
env: env,
|
||||||
dir: Some(&dir),
|
dir: Some(&dir),
|
||||||
in_fd: None,
|
in_fd: None,
|
||||||
out_fd: None,
|
out_fd: None,
|
||||||
err_fd: None
|
err_fd: None
|
||||||
});
|
});
|
||||||
let mut prog = prog.unwrap();
|
|
||||||
let outp = prog.finish_with_output();
|
let outp = prog.finish_with_output();
|
||||||
if outp.status != 0 {
|
if outp.status != 0 {
|
||||||
fail!("output was %s, error was %s",
|
fail!("output was %s, error was %s",
|
||||||
|
|
|
@ -71,6 +71,9 @@ pub struct FileStream {
|
||||||
last_nread: int,
|
last_nread: int,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl FileStream {
|
||||||
|
}
|
||||||
|
|
||||||
impl Reader for FileStream {
|
impl Reader for FileStream {
|
||||||
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
|
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
|
||||||
match self.fd.read(buf) {
|
match self.fd.read(buf) {
|
||||||
|
|
|
@ -268,9 +268,6 @@ pub use self::extensions::WriterByteConversions;
|
||||||
/// Synchronous, non-blocking file I/O.
|
/// Synchronous, non-blocking file I/O.
|
||||||
pub mod file;
|
pub mod file;
|
||||||
|
|
||||||
/// Synchronous, in-memory I/O.
|
|
||||||
pub mod pipe;
|
|
||||||
|
|
||||||
/// Synchronous, non-blocking network I/O.
|
/// Synchronous, non-blocking network I/O.
|
||||||
pub mod net {
|
pub mod net {
|
||||||
pub mod tcp;
|
pub mod tcp;
|
||||||
|
|
|
@ -16,7 +16,7 @@ use rt::io::{io_error, read_error, EndOfFile};
|
||||||
use rt::rtio::{IoFactory, IoFactoryObject,
|
use rt::rtio::{IoFactory, IoFactoryObject,
|
||||||
RtioSocket, RtioTcpListener,
|
RtioSocket, RtioTcpListener,
|
||||||
RtioTcpListenerObject, RtioTcpStream,
|
RtioTcpListenerObject, RtioTcpStream,
|
||||||
RtioTcpStreamObject, RtioStream};
|
RtioTcpStreamObject};
|
||||||
use rt::local::Local;
|
use rt::local::Local;
|
||||||
|
|
||||||
pub struct TcpStream(~RtioTcpStreamObject);
|
pub struct TcpStream(~RtioTcpStreamObject);
|
||||||
|
@ -69,7 +69,7 @@ impl TcpStream {
|
||||||
|
|
||||||
impl Reader for TcpStream {
|
impl Reader for TcpStream {
|
||||||
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
|
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
|
||||||
match (***self).read(buf) {
|
match (**self).read(buf) {
|
||||||
Ok(read) => Some(read),
|
Ok(read) => Some(read),
|
||||||
Err(ioerr) => {
|
Err(ioerr) => {
|
||||||
// EOF is indicated by returning None
|
// EOF is indicated by returning None
|
||||||
|
@ -86,7 +86,7 @@ impl Reader for TcpStream {
|
||||||
|
|
||||||
impl Writer for TcpStream {
|
impl Writer for TcpStream {
|
||||||
fn write(&mut self, buf: &[u8]) {
|
fn write(&mut self, buf: &[u8]) {
|
||||||
match (***self).write(buf) {
|
match (**self).write(buf) {
|
||||||
Ok(_) => (),
|
Ok(_) => (),
|
||||||
Err(ioerr) => io_error::cond.raise(ioerr),
|
Err(ioerr) => io_error::cond.raise(ioerr),
|
||||||
}
|
}
|
||||||
|
@ -166,7 +166,7 @@ mod test {
|
||||||
do run_in_newsched_task {
|
do run_in_newsched_task {
|
||||||
let mut called = false;
|
let mut called = false;
|
||||||
do io_error::cond.trap(|e| {
|
do io_error::cond.trap(|e| {
|
||||||
assert_eq!(e.kind, ConnectionRefused);
|
assert!(e.kind == ConnectionRefused);
|
||||||
called = true;
|
called = true;
|
||||||
}).inside {
|
}).inside {
|
||||||
let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
|
let addr = SocketAddr { ip: Ipv4Addr(0, 0, 0, 0), port: 1 };
|
||||||
|
|
|
@ -1,77 +0,0 @@
|
||||||
// Copyright 2013 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.
|
|
||||||
|
|
||||||
//! Synchronous, in-memory pipes.
|
|
||||||
//!
|
|
||||||
//! Currently these aren't particularly useful, there only exists bindings
|
|
||||||
//! enough so that pipes can be created to child processes.
|
|
||||||
|
|
||||||
use prelude::*;
|
|
||||||
use super::{Reader, Writer};
|
|
||||||
use rt::io::{io_error, read_error, EndOfFile};
|
|
||||||
use rt::local::Local;
|
|
||||||
use rt::rtio::{RtioPipeObject, RtioStream, IoFactoryObject, IoFactory};
|
|
||||||
use rt::uv::pipe;
|
|
||||||
|
|
||||||
pub struct PipeStream(~RtioPipeObject);
|
|
||||||
|
|
||||||
impl PipeStream {
|
|
||||||
/// Creates a new pipe initialized, but not bound to any particular
|
|
||||||
/// source/destination
|
|
||||||
pub fn new() -> Option<PipeStream> {
|
|
||||||
let pipe = unsafe {
|
|
||||||
let io: *mut IoFactoryObject = Local::unsafe_borrow();
|
|
||||||
(*io).pipe_init(false)
|
|
||||||
};
|
|
||||||
match pipe {
|
|
||||||
Ok(p) => Some(PipeStream(p)),
|
|
||||||
Err(ioerr) => {
|
|
||||||
io_error::cond.raise(ioerr);
|
|
||||||
None
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Extracts the underlying libuv pipe to be bound to another source.
|
|
||||||
pub fn uv_pipe(&self) -> pipe::Pipe {
|
|
||||||
// Did someone say multiple layers of indirection?
|
|
||||||
(**self).uv_pipe()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Reader for PipeStream {
|
|
||||||
fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
|
|
||||||
match (***self).read(buf) {
|
|
||||||
Ok(read) => Some(read),
|
|
||||||
Err(ioerr) => {
|
|
||||||
// EOF is indicated by returning None
|
|
||||||
if ioerr.kind != EndOfFile {
|
|
||||||
read_error::cond.raise(ioerr);
|
|
||||||
}
|
|
||||||
return None;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn eof(&mut self) -> bool { fail!() }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Writer for PipeStream {
|
|
||||||
fn write(&mut self, buf: &[u8]) {
|
|
||||||
match (***self).write(buf) {
|
|
||||||
Ok(_) => (),
|
|
||||||
Err(ioerr) => {
|
|
||||||
io_error::cond.raise(ioerr);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn flush(&mut self) { fail!() }
|
|
||||||
}
|
|
|
@ -8,14 +8,12 @@
|
||||||
// option. This file may not be copied, modified, or distributed
|
// option. This file may not be copied, modified, or distributed
|
||||||
// except according to those terms.
|
// except according to those terms.
|
||||||
|
|
||||||
use libc;
|
|
||||||
use option::*;
|
use option::*;
|
||||||
use result::*;
|
use result::*;
|
||||||
use libc::c_int;
|
use libc::c_int;
|
||||||
|
|
||||||
use rt::io::IoError;
|
use rt::io::IoError;
|
||||||
use super::io::net::ip::{IpAddr, SocketAddr};
|
use super::io::net::ip::{IpAddr, SocketAddr};
|
||||||
use rt::uv;
|
|
||||||
use rt::uv::uvio;
|
use rt::uv::uvio;
|
||||||
use path::Path;
|
use path::Path;
|
||||||
use super::io::support::PathLike;
|
use super::io::support::PathLike;
|
||||||
|
@ -32,9 +30,6 @@ pub type RtioTcpListenerObject = uvio::UvTcpListener;
|
||||||
pub type RtioUdpSocketObject = uvio::UvUdpSocket;
|
pub type RtioUdpSocketObject = uvio::UvUdpSocket;
|
||||||
pub type RtioTimerObject = uvio::UvTimer;
|
pub type RtioTimerObject = uvio::UvTimer;
|
||||||
pub type PausibleIdleCallback = uvio::UvPausibleIdleCallback;
|
pub type PausibleIdleCallback = uvio::UvPausibleIdleCallback;
|
||||||
pub type RtioPipeObject = uvio::UvPipeStream;
|
|
||||||
pub type RtioProcessObject = uvio::UvProcess;
|
|
||||||
pub type RtioProcessConfig<'self> = uv::process::Config<'self>;
|
|
||||||
|
|
||||||
pub trait EventLoop {
|
pub trait EventLoop {
|
||||||
fn run(&mut self);
|
fn run(&mut self);
|
||||||
|
@ -77,13 +72,6 @@ pub trait IoFactory {
|
||||||
fn fs_open<P: PathLike>(&mut self, path: &P, fm: FileMode, fa: FileAccess)
|
fn fs_open<P: PathLike>(&mut self, path: &P, fm: FileMode, fa: FileAccess)
|
||||||
-> Result<~RtioFileStream, IoError>;
|
-> Result<~RtioFileStream, IoError>;
|
||||||
fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
|
fn fs_unlink<P: PathLike>(&mut self, path: &P) -> Result<(), IoError>;
|
||||||
fn pipe_init(&mut self, ipc: bool) -> Result<~RtioPipeObject, IoError>;
|
|
||||||
fn spawn(&mut self, config: &RtioProcessConfig) -> Result<~RtioProcessObject, IoError>;
|
|
||||||
}
|
|
||||||
|
|
||||||
pub trait RtioStream {
|
|
||||||
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
|
|
||||||
fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait RtioTcpListener : RtioSocket {
|
pub trait RtioTcpListener : RtioSocket {
|
||||||
|
@ -92,7 +80,9 @@ pub trait RtioTcpListener : RtioSocket {
|
||||||
fn dont_accept_simultaneously(&mut self) -> Result<(), IoError>;
|
fn dont_accept_simultaneously(&mut self) -> Result<(), IoError>;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait RtioTcpStream : RtioSocket + RtioStream {
|
pub trait RtioTcpStream : RtioSocket {
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError>;
|
||||||
|
fn write(&mut self, buf: &[u8]) -> Result<(), IoError>;
|
||||||
fn peer_name(&mut self) -> Result<SocketAddr, IoError>;
|
fn peer_name(&mut self) -> Result<SocketAddr, IoError>;
|
||||||
fn control_congestion(&mut self) -> Result<(), IoError>;
|
fn control_congestion(&mut self) -> Result<(), IoError>;
|
||||||
fn nodelay(&mut self) -> Result<(), IoError>;
|
fn nodelay(&mut self) -> Result<(), IoError>;
|
||||||
|
@ -134,9 +124,3 @@ pub trait RtioFileStream {
|
||||||
fn tell(&self) -> Result<u64, IoError>;
|
fn tell(&self) -> Result<u64, IoError>;
|
||||||
fn flush(&mut self) -> Result<(), IoError>;
|
fn flush(&mut self) -> Result<(), IoError>;
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait RtioProcess {
|
|
||||||
fn id(&self) -> libc::pid_t;
|
|
||||||
fn kill(&mut self, signal: int) -> Result<(), IoError>;
|
|
||||||
fn wait(&mut self) -> int;
|
|
||||||
}
|
|
||||||
|
|
|
@ -34,7 +34,7 @@ impl AsyncWatcher {
|
||||||
|
|
||||||
extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
|
extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
|
||||||
let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
|
let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(watcher, status);
|
||||||
let data = watcher.get_watcher_data();
|
let data = watcher.get_watcher_data();
|
||||||
let cb = data.async_cb.get_ref();
|
let cb = data.async_cb.get_ref();
|
||||||
(*cb)(watcher, status);
|
(*cb)(watcher, status);
|
||||||
|
|
|
@ -11,8 +11,8 @@
|
||||||
use prelude::*;
|
use prelude::*;
|
||||||
use ptr::null;
|
use ptr::null;
|
||||||
use libc::c_void;
|
use libc::c_void;
|
||||||
use rt::uv::{Request, NativeHandle, Loop, FsCallback, Buf, UvError};
|
use rt::uv::{Request, NativeHandle, Loop, FsCallback, Buf,
|
||||||
use rt::uv::status_to_maybe_uv_error;
|
status_to_maybe_uv_error_with_loop, UvError};
|
||||||
use rt::uv::uvll;
|
use rt::uv::uvll;
|
||||||
use rt::uv::uvll::*;
|
use rt::uv::uvll::*;
|
||||||
use super::super::io::support::PathLike;
|
use super::super::io::support::PathLike;
|
||||||
|
@ -62,7 +62,7 @@ impl FsRequest {
|
||||||
pub fn open_sync<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int)
|
pub fn open_sync<P: PathLike>(loop_: &Loop, path: &P, flags: int, mode: int)
|
||||||
-> Result<int, UvError> {
|
-> Result<int, UvError> {
|
||||||
let result = FsRequest::open_common(loop_, path, flags, mode, None);
|
let result = FsRequest::open_common(loop_, path, flags, mode, None);
|
||||||
sync_cleanup(result)
|
sync_cleanup(loop_, result)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn unlink_common<P: PathLike>(loop_: &Loop, path: &P, cb: Option<FsCallback>) -> int {
|
fn unlink_common<P: PathLike>(loop_: &Loop, path: &P, cb: Option<FsCallback>) -> int {
|
||||||
|
@ -83,11 +83,11 @@ impl FsRequest {
|
||||||
}
|
}
|
||||||
pub fn unlink<P: PathLike>(loop_: &Loop, path: &P, cb: FsCallback) {
|
pub fn unlink<P: PathLike>(loop_: &Loop, path: &P, cb: FsCallback) {
|
||||||
let result = FsRequest::unlink_common(loop_, path, Some(cb));
|
let result = FsRequest::unlink_common(loop_, path, Some(cb));
|
||||||
sync_cleanup(result);
|
sync_cleanup(loop_, result);
|
||||||
}
|
}
|
||||||
pub fn unlink_sync<P: PathLike>(loop_: &Loop, path: &P) -> Result<int, UvError> {
|
pub fn unlink_sync<P: PathLike>(loop_: &Loop, path: &P) -> Result<int, UvError> {
|
||||||
let result = FsRequest::unlink_common(loop_, path, None);
|
let result = FsRequest::unlink_common(loop_, path, None);
|
||||||
sync_cleanup(result)
|
sync_cleanup(loop_, result)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn install_req_data(&self, cb: Option<FsCallback>) {
|
pub fn install_req_data(&self, cb: Option<FsCallback>) {
|
||||||
|
@ -139,8 +139,9 @@ impl NativeHandle<*uvll::uv_fs_t> for FsRequest {
|
||||||
match self { &FsRequest(ptr) => ptr }
|
match self { &FsRequest(ptr) => ptr }
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
fn sync_cleanup(result: int) -> Result<int, UvError> {
|
fn sync_cleanup(loop_: &Loop, result: int)
|
||||||
match status_to_maybe_uv_error(result as i32) {
|
-> Result<int, UvError> {
|
||||||
|
match status_to_maybe_uv_error_with_loop(loop_.native_handle(), result as i32) {
|
||||||
Some(err) => Err(err),
|
Some(err) => Err(err),
|
||||||
None => Ok(result)
|
None => Ok(result)
|
||||||
}
|
}
|
||||||
|
@ -183,7 +184,7 @@ impl FileDescriptor {
|
||||||
pub fn write_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
|
pub fn write_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
|
||||||
-> Result<int, UvError> {
|
-> Result<int, UvError> {
|
||||||
let result = self.write_common(loop_, buf, offset, None);
|
let result = self.write_common(loop_, buf, offset, None);
|
||||||
sync_cleanup(result)
|
sync_cleanup(loop_, result)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn read_common(&mut self, loop_: &Loop, buf: Buf,
|
fn read_common(&mut self, loop_: &Loop, buf: Buf,
|
||||||
|
@ -211,7 +212,7 @@ impl FileDescriptor {
|
||||||
pub fn read_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
|
pub fn read_sync(&mut self, loop_: &Loop, buf: Buf, offset: i64)
|
||||||
-> Result<int, UvError> {
|
-> Result<int, UvError> {
|
||||||
let result = self.read_common(loop_, buf, offset, None);
|
let result = self.read_common(loop_, buf, offset, None);
|
||||||
sync_cleanup(result)
|
sync_cleanup(loop_, result)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn close_common(self, loop_: &Loop, cb: Option<FsCallback>) -> int {
|
fn close_common(self, loop_: &Loop, cb: Option<FsCallback>) -> int {
|
||||||
|
@ -233,11 +234,12 @@ impl FileDescriptor {
|
||||||
}
|
}
|
||||||
pub fn close_sync(self, loop_: &Loop) -> Result<int, UvError> {
|
pub fn close_sync(self, loop_: &Loop) -> Result<int, UvError> {
|
||||||
let result = self.close_common(loop_, None);
|
let result = self.close_common(loop_, None);
|
||||||
sync_cleanup(result)
|
sync_cleanup(loop_, result)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
extern fn compl_cb(req: *uv_fs_t) {
|
extern fn compl_cb(req: *uv_fs_t) {
|
||||||
let mut req: FsRequest = NativeHandle::from_native_handle(req);
|
let mut req: FsRequest = NativeHandle::from_native_handle(req);
|
||||||
|
let loop_ = req.get_loop();
|
||||||
// pull the user cb out of the req data
|
// pull the user cb out of the req data
|
||||||
let cb = {
|
let cb = {
|
||||||
let data = req.get_req_data();
|
let data = req.get_req_data();
|
||||||
|
@ -248,7 +250,8 @@ extern fn compl_cb(req: *uv_fs_t) {
|
||||||
// in uv_fs_open calls, the result will be the fd in the
|
// in uv_fs_open calls, the result will be the fd in the
|
||||||
// case of success, otherwise it's -1 indicating an error
|
// case of success, otherwise it's -1 indicating an error
|
||||||
let result = req.get_result();
|
let result = req.get_result();
|
||||||
let status = status_to_maybe_uv_error(result);
|
let status = status_to_maybe_uv_error_with_loop(
|
||||||
|
loop_.native_handle(), result);
|
||||||
// we have a req and status, call the user cb..
|
// we have a req and status, call the user cb..
|
||||||
// only giving the user a ref to the FsRequest, as we
|
// only giving the user a ref to the FsRequest, as we
|
||||||
// have to clean it up, afterwards (and they aren't really
|
// have to clean it up, afterwards (and they aren't really
|
||||||
|
|
|
@ -43,7 +43,7 @@ impl IdleWatcher {
|
||||||
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
|
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let data = idle_watcher.get_watcher_data();
|
let data = idle_watcher.get_watcher_data();
|
||||||
let cb: &IdleCallback = data.idle_cb.get_ref();
|
let cb: &IdleCallback = data.idle_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(idle_watcher, status);
|
||||||
(*cb)(idle_watcher, status);
|
(*cb)(idle_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -57,7 +57,7 @@ impl IdleWatcher {
|
||||||
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
|
let mut idle_watcher: IdleWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let data = idle_watcher.get_watcher_data();
|
let data = idle_watcher.get_watcher_data();
|
||||||
let cb: &IdleCallback = data.idle_cb.get_ref();
|
let cb: &IdleCallback = data.idle_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(idle_watcher, status);
|
||||||
(*cb)(idle_watcher, status);
|
(*cb)(idle_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -58,8 +58,6 @@ pub use self::net::{StreamWatcher, TcpWatcher, UdpWatcher};
|
||||||
pub use self::idle::IdleWatcher;
|
pub use self::idle::IdleWatcher;
|
||||||
pub use self::timer::TimerWatcher;
|
pub use self::timer::TimerWatcher;
|
||||||
pub use self::async::AsyncWatcher;
|
pub use self::async::AsyncWatcher;
|
||||||
pub use self::process::Process;
|
|
||||||
pub use self::pipe::Pipe;
|
|
||||||
|
|
||||||
/// The implementation of `rtio` for libuv
|
/// The implementation of `rtio` for libuv
|
||||||
pub mod uvio;
|
pub mod uvio;
|
||||||
|
@ -72,8 +70,6 @@ pub mod net;
|
||||||
pub mod idle;
|
pub mod idle;
|
||||||
pub mod timer;
|
pub mod timer;
|
||||||
pub mod async;
|
pub mod async;
|
||||||
pub mod process;
|
|
||||||
pub mod pipe;
|
|
||||||
|
|
||||||
/// XXX: Loop(*handle) is buggy with destructors. Normal structs
|
/// XXX: Loop(*handle) is buggy with destructors. Normal structs
|
||||||
/// with dtors may not be destructured, but tuple structs can,
|
/// with dtors may not be destructured, but tuple structs can,
|
||||||
|
@ -130,8 +126,6 @@ pub type NullCallback = ~fn();
|
||||||
pub type IdleCallback = ~fn(IdleWatcher, Option<UvError>);
|
pub type IdleCallback = ~fn(IdleWatcher, Option<UvError>);
|
||||||
pub type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
|
pub type ConnectionCallback = ~fn(StreamWatcher, Option<UvError>);
|
||||||
pub type FsCallback = ~fn(&mut FsRequest, Option<UvError>);
|
pub type FsCallback = ~fn(&mut FsRequest, Option<UvError>);
|
||||||
// first int is exit_status, second is term_signal
|
|
||||||
pub type ExitCallback = ~fn(Process, int, int, Option<UvError>);
|
|
||||||
pub type TimerCallback = ~fn(TimerWatcher, Option<UvError>);
|
pub type TimerCallback = ~fn(TimerWatcher, Option<UvError>);
|
||||||
pub type AsyncCallback = ~fn(AsyncWatcher, Option<UvError>);
|
pub type AsyncCallback = ~fn(AsyncWatcher, Option<UvError>);
|
||||||
pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, SocketAddr, uint, Option<UvError>);
|
pub type UdpReceiveCallback = ~fn(UdpWatcher, int, Buf, SocketAddr, uint, Option<UvError>);
|
||||||
|
@ -149,8 +143,7 @@ struct WatcherData {
|
||||||
timer_cb: Option<TimerCallback>,
|
timer_cb: Option<TimerCallback>,
|
||||||
async_cb: Option<AsyncCallback>,
|
async_cb: Option<AsyncCallback>,
|
||||||
udp_recv_cb: Option<UdpReceiveCallback>,
|
udp_recv_cb: Option<UdpReceiveCallback>,
|
||||||
udp_send_cb: Option<UdpSendCallback>,
|
udp_send_cb: Option<UdpSendCallback>
|
||||||
exit_cb: Option<ExitCallback>,
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub trait WatcherInterop {
|
pub trait WatcherInterop {
|
||||||
|
@ -182,8 +175,7 @@ impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
|
||||||
timer_cb: None,
|
timer_cb: None,
|
||||||
async_cb: None,
|
async_cb: None,
|
||||||
udp_recv_cb: None,
|
udp_recv_cb: None,
|
||||||
udp_send_cb: None,
|
udp_send_cb: None
|
||||||
exit_cb: None,
|
|
||||||
};
|
};
|
||||||
let data = transmute::<~WatcherData, *c_void>(data);
|
let data = transmute::<~WatcherData, *c_void>(data);
|
||||||
uvll::set_data_for_uv_handle(self.native_handle(), data);
|
uvll::set_data_for_uv_handle(self.native_handle(), data);
|
||||||
|
@ -210,12 +202,12 @@ impl<H, W: Watcher + NativeHandle<*H>> WatcherInterop for W {
|
||||||
// XXX: Need to define the error constants like EOF so they can be
|
// XXX: Need to define the error constants like EOF so they can be
|
||||||
// compared to the UvError type
|
// compared to the UvError type
|
||||||
|
|
||||||
pub struct UvError(c_int);
|
pub struct UvError(uvll::uv_err_t);
|
||||||
|
|
||||||
impl UvError {
|
impl UvError {
|
||||||
pub fn name(&self) -> ~str {
|
pub fn name(&self) -> ~str {
|
||||||
unsafe {
|
unsafe {
|
||||||
let inner = match self { &UvError(a) => a };
|
let inner = match self { &UvError(ref a) => a };
|
||||||
let name_str = uvll::err_name(inner);
|
let name_str = uvll::err_name(inner);
|
||||||
assert!(name_str.is_not_null());
|
assert!(name_str.is_not_null());
|
||||||
from_c_str(name_str)
|
from_c_str(name_str)
|
||||||
|
@ -224,7 +216,7 @@ impl UvError {
|
||||||
|
|
||||||
pub fn desc(&self) -> ~str {
|
pub fn desc(&self) -> ~str {
|
||||||
unsafe {
|
unsafe {
|
||||||
let inner = match self { &UvError(a) => a };
|
let inner = match self { &UvError(ref a) => a };
|
||||||
let desc_str = uvll::strerror(inner);
|
let desc_str = uvll::strerror(inner);
|
||||||
assert!(desc_str.is_not_null());
|
assert!(desc_str.is_not_null());
|
||||||
from_c_str(desc_str)
|
from_c_str(desc_str)
|
||||||
|
@ -232,7 +224,7 @@ impl UvError {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn is_eof(&self) -> bool {
|
pub fn is_eof(&self) -> bool {
|
||||||
**self == uvll::EOF
|
self.code == uvll::EOF
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -244,10 +236,18 @@ impl ToStr for UvError {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn error_smoke_test() {
|
fn error_smoke_test() {
|
||||||
let err: UvError = UvError(uvll::EOF);
|
let err = uvll::uv_err_t { code: 1, sys_errno_: 1 };
|
||||||
|
let err: UvError = UvError(err);
|
||||||
assert_eq!(err.to_str(), ~"EOF: end of file");
|
assert_eq!(err.to_str(), ~"EOF: end of file");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn last_uv_error<H, W: Watcher + NativeHandle<*H>>(watcher: &W) -> UvError {
|
||||||
|
unsafe {
|
||||||
|
let loop_ = watcher.event_loop();
|
||||||
|
UvError(uvll::last_error(loop_.native_handle()))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
|
pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
|
||||||
unsafe {
|
unsafe {
|
||||||
// Importing error constants
|
// Importing error constants
|
||||||
|
@ -255,10 +255,10 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
|
||||||
use rt::io::*;
|
use rt::io::*;
|
||||||
|
|
||||||
// uv error descriptions are static
|
// uv error descriptions are static
|
||||||
let c_desc = uvll::strerror(*uverr);
|
let c_desc = uvll::strerror(&*uverr);
|
||||||
let desc = str::raw::c_str_to_static_slice(c_desc);
|
let desc = str::raw::c_str_to_static_slice(c_desc);
|
||||||
|
|
||||||
let kind = match *uverr {
|
let kind = match uverr.code {
|
||||||
UNKNOWN => OtherIoError,
|
UNKNOWN => OtherIoError,
|
||||||
OK => OtherIoError,
|
OK => OtherIoError,
|
||||||
EOF => EndOfFile,
|
EOF => EndOfFile,
|
||||||
|
@ -266,8 +266,8 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
|
||||||
ECONNREFUSED => ConnectionRefused,
|
ECONNREFUSED => ConnectionRefused,
|
||||||
ECONNRESET => ConnectionReset,
|
ECONNRESET => ConnectionReset,
|
||||||
EPIPE => BrokenPipe,
|
EPIPE => BrokenPipe,
|
||||||
err => {
|
_ => {
|
||||||
rtdebug!("uverr.code %d", err as int);
|
rtdebug!("uverr.code %u", uverr.code as uint);
|
||||||
// XXX: Need to map remaining uv error types
|
// XXX: Need to map remaining uv error types
|
||||||
OtherIoError
|
OtherIoError
|
||||||
}
|
}
|
||||||
|
@ -281,12 +281,31 @@ pub fn uv_error_to_io_error(uverr: UvError) -> IoError {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Convert a callback status to a UvError
|
/// Given a uv handle, convert a callback status to a UvError
|
||||||
pub fn status_to_maybe_uv_error(status: c_int) -> Option<UvError> {
|
pub fn status_to_maybe_uv_error_with_loop(
|
||||||
if status >= 0 {
|
loop_: *uvll::uv_loop_t,
|
||||||
|
status: c_int) -> Option<UvError> {
|
||||||
|
if status != -1 {
|
||||||
None
|
None
|
||||||
} else {
|
} else {
|
||||||
Some(UvError(status))
|
unsafe {
|
||||||
|
rtdebug!("loop: %x", loop_ as uint);
|
||||||
|
let err = uvll::last_error(loop_);
|
||||||
|
Some(UvError(err))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/// Given a uv handle, convert a callback status to a UvError
|
||||||
|
pub fn status_to_maybe_uv_error<T, U: Watcher + NativeHandle<*T>>(handle: U,
|
||||||
|
status: c_int) -> Option<UvError> {
|
||||||
|
if status != -1 {
|
||||||
|
None
|
||||||
|
} else {
|
||||||
|
unsafe {
|
||||||
|
rtdebug!("handle: %x", handle.native_handle() as uint);
|
||||||
|
let loop_ = uvll::get_loop_for_uv_handle(handle.native_handle());
|
||||||
|
status_to_maybe_uv_error_with_loop(loop_, status)
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -16,6 +16,7 @@ use rt::uv::{AllocCallback, ConnectionCallback, ReadCallback, UdpReceiveCallback
|
||||||
use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle, NullCallback,
|
use rt::uv::{Loop, Watcher, Request, UvError, Buf, NativeHandle, NullCallback,
|
||||||
status_to_maybe_uv_error};
|
status_to_maybe_uv_error};
|
||||||
use rt::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
|
use rt::io::net::ip::{SocketAddr, Ipv4Addr, Ipv6Addr};
|
||||||
|
use rt::uv::last_uv_error;
|
||||||
use vec;
|
use vec;
|
||||||
use str;
|
use str;
|
||||||
use from_str::{FromStr};
|
use from_str::{FromStr};
|
||||||
|
@ -136,7 +137,7 @@ impl StreamWatcher {
|
||||||
rtdebug!("buf len: %d", buf.len as int);
|
rtdebug!("buf len: %d", buf.len as int);
|
||||||
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
|
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(stream);
|
||||||
let cb = stream_watcher.get_watcher_data().read_cb.get_ref();
|
let cb = stream_watcher.get_watcher_data().read_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(nread as c_int);
|
let status = status_to_maybe_uv_error(stream_watcher, nread as c_int);
|
||||||
(*cb)(stream_watcher, nread as int, buf, status);
|
(*cb)(stream_watcher, nread as int, buf, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -166,7 +167,7 @@ impl StreamWatcher {
|
||||||
let mut stream_watcher = write_request.stream();
|
let mut stream_watcher = write_request.stream();
|
||||||
write_request.delete();
|
write_request.delete();
|
||||||
let cb = stream_watcher.get_watcher_data().write_cb.take_unwrap();
|
let cb = stream_watcher.get_watcher_data().write_cb.take_unwrap();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(stream_watcher, status);
|
||||||
cb(stream_watcher, status);
|
cb(stream_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -231,7 +232,7 @@ impl TcpWatcher {
|
||||||
};
|
};
|
||||||
match result {
|
match result {
|
||||||
0 => Ok(()),
|
0 => Ok(()),
|
||||||
_ => Err(UvError(result)),
|
_ => Err(last_uv_error(self)),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -259,7 +260,7 @@ impl TcpWatcher {
|
||||||
let mut stream_watcher = connect_request.stream();
|
let mut stream_watcher = connect_request.stream();
|
||||||
connect_request.delete();
|
connect_request.delete();
|
||||||
let cb = stream_watcher.get_watcher_data().connect_cb.take_unwrap();
|
let cb = stream_watcher.get_watcher_data().connect_cb.take_unwrap();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(stream_watcher, status);
|
||||||
cb(stream_watcher, status);
|
cb(stream_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -282,7 +283,7 @@ impl TcpWatcher {
|
||||||
rtdebug!("connection_cb");
|
rtdebug!("connection_cb");
|
||||||
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
|
let mut stream_watcher: StreamWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let cb = stream_watcher.get_watcher_data().connect_cb.get_ref();
|
let cb = stream_watcher.get_watcher_data().connect_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(stream_watcher, status);
|
||||||
(*cb)(stream_watcher, status);
|
(*cb)(stream_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -326,7 +327,7 @@ impl UdpWatcher {
|
||||||
};
|
};
|
||||||
match result {
|
match result {
|
||||||
0 => Ok(()),
|
0 => Ok(()),
|
||||||
_ => Err(UvError(result)),
|
_ => Err(last_uv_error(self)),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -359,7 +360,7 @@ impl UdpWatcher {
|
||||||
rtdebug!("buf len: %d", buf.len as int);
|
rtdebug!("buf len: %d", buf.len as int);
|
||||||
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
|
let mut udp_watcher: UdpWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref();
|
let cb = udp_watcher.get_watcher_data().udp_recv_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(nread as c_int);
|
let status = status_to_maybe_uv_error(udp_watcher, nread as c_int);
|
||||||
let addr = uv_socket_addr_to_socket_addr(sockaddr_to_UvSocketAddr(addr));
|
let addr = uv_socket_addr_to_socket_addr(sockaddr_to_UvSocketAddr(addr));
|
||||||
(*cb)(udp_watcher, nread as int, buf, addr, flags as uint, status);
|
(*cb)(udp_watcher, nread as int, buf, addr, flags as uint, status);
|
||||||
}
|
}
|
||||||
|
@ -394,7 +395,7 @@ impl UdpWatcher {
|
||||||
let mut udp_watcher = send_request.handle();
|
let mut udp_watcher = send_request.handle();
|
||||||
send_request.delete();
|
send_request.delete();
|
||||||
let cb = udp_watcher.get_watcher_data().udp_send_cb.take_unwrap();
|
let cb = udp_watcher.get_watcher_data().udp_send_cb.take_unwrap();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(udp_watcher, status);
|
||||||
cb(udp_watcher, status);
|
cb(udp_watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,66 +0,0 @@
|
||||||
// Copyright 2013 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.
|
|
||||||
|
|
||||||
use prelude::*;
|
|
||||||
use libc;
|
|
||||||
|
|
||||||
use rt::uv;
|
|
||||||
use rt::uv::net;
|
|
||||||
use rt::uv::uvll;
|
|
||||||
|
|
||||||
pub struct Pipe(*uvll::uv_pipe_t);
|
|
||||||
|
|
||||||
impl uv::Watcher for Pipe {}
|
|
||||||
|
|
||||||
impl Pipe {
|
|
||||||
pub fn new(loop_: &uv::Loop, ipc: bool) -> Pipe {
|
|
||||||
unsafe {
|
|
||||||
let handle = uvll::malloc_handle(uvll::UV_NAMED_PIPE);
|
|
||||||
assert!(handle.is_not_null());
|
|
||||||
let ipc = ipc as libc::c_int;
|
|
||||||
assert_eq!(uvll::pipe_init(loop_.native_handle(), handle, ipc), 0);
|
|
||||||
let mut ret: Pipe =
|
|
||||||
uv::NativeHandle::from_native_handle(handle);
|
|
||||||
ret.install_watcher_data();
|
|
||||||
ret
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn as_stream(&self) -> net::StreamWatcher {
|
|
||||||
net::StreamWatcher(**self as *uvll::uv_stream_t)
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn close(self, cb: uv::NullCallback) {
|
|
||||||
{
|
|
||||||
let mut this = self;
|
|
||||||
let data = this.get_watcher_data();
|
|
||||||
assert!(data.close_cb.is_none());
|
|
||||||
data.close_cb = Some(cb);
|
|
||||||
}
|
|
||||||
|
|
||||||
unsafe { uvll::close(self.native_handle(), close_cb); }
|
|
||||||
|
|
||||||
extern fn close_cb(handle: *uvll::uv_pipe_t) {
|
|
||||||
let mut process: Pipe = uv::NativeHandle::from_native_handle(handle);
|
|
||||||
process.get_watcher_data().close_cb.take_unwrap()();
|
|
||||||
process.drop_watcher_data();
|
|
||||||
unsafe { uvll::free_handle(handle as *libc::c_void) }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl uv::NativeHandle<*uvll::uv_pipe_t> for Pipe {
|
|
||||||
fn from_native_handle(handle: *uvll::uv_pipe_t) -> Pipe {
|
|
||||||
Pipe(handle)
|
|
||||||
}
|
|
||||||
fn native_handle(&self) -> *uvll::uv_pipe_t {
|
|
||||||
match self { &Pipe(ptr) => ptr }
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -1,264 +0,0 @@
|
||||||
// Copyright 2013 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.
|
|
||||||
|
|
||||||
use prelude::*;
|
|
||||||
use libc;
|
|
||||||
use ptr;
|
|
||||||
use vec;
|
|
||||||
use cell::Cell;
|
|
||||||
|
|
||||||
use rt::uv;
|
|
||||||
use rt::uv::net;
|
|
||||||
use rt::uv::pipe;
|
|
||||||
use rt::uv::uvll;
|
|
||||||
|
|
||||||
/// A process wraps the handle of the underlying uv_process_t.
|
|
||||||
pub struct Process(*uvll::uv_process_t);
|
|
||||||
|
|
||||||
/// This configuration describes how a new process should be spawned. This is
|
|
||||||
/// translated to libuv's own configuration
|
|
||||||
pub struct Config<'self> {
|
|
||||||
/// Path to the program to run
|
|
||||||
program: &'self str,
|
|
||||||
|
|
||||||
/// Arguments to pass to the program (doesn't include the program itself)
|
|
||||||
args: &'self [~str],
|
|
||||||
|
|
||||||
/// Optional environment to specify for the program. If this is None, then
|
|
||||||
/// it will inherit the current process's environment.
|
|
||||||
env: Option<&'self [(~str, ~str)]>,
|
|
||||||
|
|
||||||
/// Optional working directory for the new process. If this is None, then
|
|
||||||
/// the current directory of the running process is inherited.
|
|
||||||
cwd: Option<&'self str>,
|
|
||||||
|
|
||||||
/// Any number of streams/file descriptors/pipes may be attached to this
|
|
||||||
/// process. This list enumerates the file descriptors and such for the
|
|
||||||
/// process to be spawned, and the file descriptors inherited will start at
|
|
||||||
/// 0 and go to the length of this array.
|
|
||||||
///
|
|
||||||
/// Standard file descriptors are:
|
|
||||||
///
|
|
||||||
/// 0 - stdin
|
|
||||||
/// 1 - stdout
|
|
||||||
/// 2 - stderr
|
|
||||||
io: &'self [StdioContainer]
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Describes what to do with a standard io stream for a child process.
|
|
||||||
pub enum StdioContainer {
|
|
||||||
/// This stream will be ignored. This is the equivalent of attaching the
|
|
||||||
/// stream to `/dev/null`
|
|
||||||
Ignored,
|
|
||||||
|
|
||||||
/// The specified file descriptor is inherited for the stream which it is
|
|
||||||
/// specified for.
|
|
||||||
InheritFd(libc::c_int),
|
|
||||||
|
|
||||||
/// The specified libuv stream is inherited for the corresponding file
|
|
||||||
/// descriptor it is assigned to.
|
|
||||||
InheritStream(net::StreamWatcher),
|
|
||||||
|
|
||||||
/// Creates a pipe for the specified file descriptor which will be directed
|
|
||||||
/// into the previously-initialized pipe passed in.
|
|
||||||
///
|
|
||||||
/// The first boolean argument is whether the pipe is readable, and the
|
|
||||||
/// second is whether it is writable. These properties are from the view of
|
|
||||||
/// the *child* process, not the parent process.
|
|
||||||
CreatePipe(pipe::Pipe, bool /* readable */, bool /* writable */),
|
|
||||||
}
|
|
||||||
|
|
||||||
impl uv::Watcher for Process {}
|
|
||||||
|
|
||||||
impl Process {
|
|
||||||
/// Creates a new process, ready to spawn inside an event loop
|
|
||||||
pub fn new() -> Process {
|
|
||||||
let handle = unsafe { uvll::malloc_handle(uvll::UV_PROCESS) };
|
|
||||||
assert!(handle.is_not_null());
|
|
||||||
let mut ret: Process = uv::NativeHandle::from_native_handle(handle);
|
|
||||||
ret.install_watcher_data();
|
|
||||||
return ret;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Spawn a new process inside the specified event loop.
|
|
||||||
///
|
|
||||||
/// The `config` variable will be passed down to libuv, and the `exit_cb`
|
|
||||||
/// will be run only once, when the process exits.
|
|
||||||
///
|
|
||||||
/// Returns either the corresponding process object or an error which
|
|
||||||
/// occurred.
|
|
||||||
pub fn spawn(&mut self, loop_: &uv::Loop, config: &Config,
|
|
||||||
exit_cb: uv::ExitCallback) -> Result<(), uv::UvError> {
|
|
||||||
let cwd = config.cwd.map_move(|s| s.to_c_str());
|
|
||||||
|
|
||||||
extern fn on_exit(p: *uvll::uv_process_t,
|
|
||||||
exit_status: libc::c_int,
|
|
||||||
term_signal: libc::c_int) {
|
|
||||||
let mut p: Process = uv::NativeHandle::from_native_handle(p);
|
|
||||||
let err = match exit_status {
|
|
||||||
0 => None,
|
|
||||||
_ => uv::status_to_maybe_uv_error(-1)
|
|
||||||
};
|
|
||||||
p.get_watcher_data().exit_cb.take_unwrap()(p,
|
|
||||||
exit_status as int,
|
|
||||||
term_signal as int,
|
|
||||||
err);
|
|
||||||
}
|
|
||||||
|
|
||||||
let mut stdio = vec::with_capacity::<uvll::uv_stdio_container_t>(
|
|
||||||
config.io.len());
|
|
||||||
unsafe {
|
|
||||||
vec::raw::set_len(&mut stdio, config.io.len());
|
|
||||||
for (slot, &other) in stdio.iter().zip(config.io.iter()) {
|
|
||||||
set_stdio(slot as *uvll::uv_stdio_container_t, other);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
let exit_cb = Cell::new(exit_cb);
|
|
||||||
do with_argv(config.program, config.args) |argv| {
|
|
||||||
do with_env(config.env) |envp| {
|
|
||||||
let options = uvll::uv_process_options_t {
|
|
||||||
exit_cb: on_exit,
|
|
||||||
file: unsafe { *argv },
|
|
||||||
args: argv,
|
|
||||||
env: envp,
|
|
||||||
cwd: match cwd {
|
|
||||||
Some(ref cwd) => cwd.with_ref(|p| p),
|
|
||||||
None => ptr::null(),
|
|
||||||
},
|
|
||||||
flags: 0,
|
|
||||||
stdio_count: stdio.len() as libc::c_int,
|
|
||||||
stdio: stdio.as_imm_buf(|p, _| p),
|
|
||||||
uid: 0,
|
|
||||||
gid: 0,
|
|
||||||
};
|
|
||||||
|
|
||||||
match unsafe {
|
|
||||||
uvll::spawn(loop_.native_handle(), **self, options)
|
|
||||||
} {
|
|
||||||
0 => {
|
|
||||||
(*self).get_watcher_data().exit_cb = Some(exit_cb.take());
|
|
||||||
Ok(())
|
|
||||||
}
|
|
||||||
err => Err(uv::UvError(err))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Sends a signal to this process.
|
|
||||||
///
|
|
||||||
/// This is a wrapper around `uv_process_kill`
|
|
||||||
pub fn kill(&self, signum: int) -> Result<(), uv::UvError> {
|
|
||||||
match unsafe {
|
|
||||||
uvll::process_kill(self.native_handle(), signum as libc::c_int)
|
|
||||||
} {
|
|
||||||
0 => Ok(()),
|
|
||||||
err => Err(uv::UvError(err))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Returns the process id of a spawned process
|
|
||||||
pub fn pid(&self) -> libc::pid_t {
|
|
||||||
unsafe { uvll::process_pid(**self) as libc::pid_t }
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Closes this handle, invoking the specified callback once closed
|
|
||||||
pub fn close(self, cb: uv::NullCallback) {
|
|
||||||
{
|
|
||||||
let mut this = self;
|
|
||||||
let data = this.get_watcher_data();
|
|
||||||
assert!(data.close_cb.is_none());
|
|
||||||
data.close_cb = Some(cb);
|
|
||||||
}
|
|
||||||
|
|
||||||
unsafe { uvll::close(self.native_handle(), close_cb); }
|
|
||||||
|
|
||||||
extern fn close_cb(handle: *uvll::uv_process_t) {
|
|
||||||
let mut process: Process = uv::NativeHandle::from_native_handle(handle);
|
|
||||||
process.get_watcher_data().close_cb.take_unwrap()();
|
|
||||||
process.drop_watcher_data();
|
|
||||||
unsafe { uvll::free_handle(handle as *libc::c_void) }
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
unsafe fn set_stdio(dst: *uvll::uv_stdio_container_t, io: StdioContainer) {
|
|
||||||
match io {
|
|
||||||
Ignored => { uvll::set_stdio_container_flags(dst, uvll::STDIO_IGNORE); }
|
|
||||||
InheritFd(fd) => {
|
|
||||||
uvll::set_stdio_container_flags(dst, uvll::STDIO_INHERIT_FD);
|
|
||||||
uvll::set_stdio_container_fd(dst, fd);
|
|
||||||
}
|
|
||||||
InheritStream(stream) => {
|
|
||||||
uvll::set_stdio_container_flags(dst, uvll::STDIO_INHERIT_STREAM);
|
|
||||||
uvll::set_stdio_container_stream(dst, stream.native_handle());
|
|
||||||
}
|
|
||||||
CreatePipe(pipe, readable, writable) => {
|
|
||||||
let mut flags = uvll::STDIO_CREATE_PIPE as libc::c_int;
|
|
||||||
if readable {
|
|
||||||
flags |= uvll::STDIO_READABLE_PIPE as libc::c_int;
|
|
||||||
}
|
|
||||||
if writable {
|
|
||||||
flags |= uvll::STDIO_WRITABLE_PIPE as libc::c_int;
|
|
||||||
}
|
|
||||||
uvll::set_stdio_container_flags(dst, flags);
|
|
||||||
uvll::set_stdio_container_stream(dst,
|
|
||||||
pipe.as_stream().native_handle());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the program and arguments to the argv array expected by libuv
|
|
||||||
fn with_argv<T>(prog: &str, args: &[~str], f: &fn(**libc::c_char) -> T) -> T {
|
|
||||||
// First, allocation space to put all the C-strings (we need to have
|
|
||||||
// ownership of them somewhere
|
|
||||||
let mut c_strs = vec::with_capacity(args.len() + 1);
|
|
||||||
c_strs.push(prog.to_c_str());
|
|
||||||
for arg in args.iter() {
|
|
||||||
c_strs.push(arg.to_c_str());
|
|
||||||
}
|
|
||||||
|
|
||||||
// Next, create the char** array
|
|
||||||
let mut c_args = vec::with_capacity(c_strs.len() + 1);
|
|
||||||
for s in c_strs.iter() {
|
|
||||||
c_args.push(s.with_ref(|p| p));
|
|
||||||
}
|
|
||||||
c_args.push(ptr::null());
|
|
||||||
c_args.as_imm_buf(|buf, _| f(buf))
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Converts the environment to the env array expected by libuv
|
|
||||||
fn with_env<T>(env: Option<&[(~str, ~str)]>, f: &fn(**libc::c_char) -> T) -> T {
|
|
||||||
let env = match env {
|
|
||||||
Some(s) => s,
|
|
||||||
None => { return f(ptr::null()); }
|
|
||||||
};
|
|
||||||
// As with argv, create some temporary storage and then the actual array
|
|
||||||
let mut envp = vec::with_capacity(env.len());
|
|
||||||
for &(ref key, ref value) in env.iter() {
|
|
||||||
envp.push(fmt!("%s=%s", *key, *value).to_c_str());
|
|
||||||
}
|
|
||||||
let mut c_envp = vec::with_capacity(envp.len() + 1);
|
|
||||||
for s in envp.iter() {
|
|
||||||
c_envp.push(s.with_ref(|p| p));
|
|
||||||
}
|
|
||||||
c_envp.push(ptr::null());
|
|
||||||
c_envp.as_imm_buf(|buf, _| f(buf))
|
|
||||||
}
|
|
||||||
|
|
||||||
impl uv::NativeHandle<*uvll::uv_process_t> for Process {
|
|
||||||
fn from_native_handle(handle: *uvll::uv_process_t) -> Process {
|
|
||||||
Process(handle)
|
|
||||||
}
|
|
||||||
fn native_handle(&self) -> *uvll::uv_process_t {
|
|
||||||
match self { &Process(ptr) => ptr }
|
|
||||||
}
|
|
||||||
}
|
|
|
@ -43,7 +43,7 @@ impl TimerWatcher {
|
||||||
let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle);
|
let mut watcher: TimerWatcher = NativeHandle::from_native_handle(handle);
|
||||||
let data = watcher.get_watcher_data();
|
let data = watcher.get_watcher_data();
|
||||||
let cb = data.timer_cb.get_ref();
|
let cb = data.timer_cb.get_ref();
|
||||||
let status = status_to_maybe_uv_error(status);
|
let status = status_to_maybe_uv_error(watcher, status);
|
||||||
(*cb)(watcher, status);
|
(*cb)(watcher, status);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
@ -13,7 +13,7 @@ use cast::transmute;
|
||||||
use cast;
|
use cast;
|
||||||
use cell::Cell;
|
use cell::Cell;
|
||||||
use clone::Clone;
|
use clone::Clone;
|
||||||
use libc::{c_int, c_uint, c_void, pid_t};
|
use libc::{c_int, c_uint, c_void};
|
||||||
use ops::Drop;
|
use ops::Drop;
|
||||||
use option::*;
|
use option::*;
|
||||||
use ptr;
|
use ptr;
|
||||||
|
@ -22,7 +22,6 @@ use result::*;
|
||||||
use rt::io::IoError;
|
use rt::io::IoError;
|
||||||
use rt::io::net::ip::{SocketAddr, IpAddr};
|
use rt::io::net::ip::{SocketAddr, IpAddr};
|
||||||
use rt::io::{standard_error, OtherIoError, SeekStyle, SeekSet, SeekCur, SeekEnd};
|
use rt::io::{standard_error, OtherIoError, SeekStyle, SeekSet, SeekCur, SeekEnd};
|
||||||
use rt::kill::BlockedTask;
|
|
||||||
use rt::local::Local;
|
use rt::local::Local;
|
||||||
use rt::rtio::*;
|
use rt::rtio::*;
|
||||||
use rt::sched::{Scheduler, SchedHandle};
|
use rt::sched::{Scheduler, SchedHandle};
|
||||||
|
@ -149,7 +148,7 @@ fn socket_name<T, U: Watcher + NativeHandle<*T>>(sk: SocketNameKind,
|
||||||
};
|
};
|
||||||
|
|
||||||
if r != 0 {
|
if r != 0 {
|
||||||
let status = status_to_maybe_uv_error(r);
|
let status = status_to_maybe_uv_error(handle, r);
|
||||||
return Err(uv_error_to_io_error(status.unwrap()));
|
return Err(uv_error_to_io_error(status.unwrap()));
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -592,63 +591,6 @@ impl IoFactory for UvIoFactory {
|
||||||
assert!(!result_cell.is_empty());
|
assert!(!result_cell.is_empty());
|
||||||
return result_cell.take();
|
return result_cell.take();
|
||||||
}
|
}
|
||||||
|
|
||||||
fn pipe_init(&mut self, ipc: bool) -> Result<~RtioPipeObject, IoError> {
|
|
||||||
let home = get_handle_to_current_scheduler!();
|
|
||||||
Ok(~UvPipeStream { pipe: Pipe::new(self.uv_loop(), ipc), home: home })
|
|
||||||
}
|
|
||||||
|
|
||||||
fn spawn(&mut self,
|
|
||||||
config: &process::Config) -> Result<~RtioProcessObject, IoError> {
|
|
||||||
// Sadly, we must create the UvProcess before we actually call uv_spawn
|
|
||||||
// so that the exit_cb can close over it and notify it when the process
|
|
||||||
// has exited.
|
|
||||||
let mut ret = ~UvProcess {
|
|
||||||
process: Process::new(),
|
|
||||||
home: None,
|
|
||||||
exit_status: None,
|
|
||||||
term_signal: None,
|
|
||||||
exit_error: None,
|
|
||||||
descheduled: None,
|
|
||||||
};
|
|
||||||
let ret_ptr = unsafe {
|
|
||||||
*cast::transmute::<&~UvProcess, &*mut UvProcess>(&ret)
|
|
||||||
};
|
|
||||||
|
|
||||||
// The purpose of this exit callback is to record the data about the
|
|
||||||
// exit and then wake up the task which may be waiting for the process
|
|
||||||
// to exit. This is all performed in the current io-loop, and the
|
|
||||||
// implementation of UvProcess ensures that reading these fields always
|
|
||||||
// occurs on the current io-loop.
|
|
||||||
let exit_cb: ExitCallback = |_, exit_status, term_signal, error| {
|
|
||||||
unsafe {
|
|
||||||
assert!((*ret_ptr).exit_status.is_none());
|
|
||||||
(*ret_ptr).exit_status = Some(exit_status);
|
|
||||||
(*ret_ptr).term_signal = Some(term_signal);
|
|
||||||
(*ret_ptr).exit_error = error;
|
|
||||||
match (*ret_ptr).descheduled.take() {
|
|
||||||
Some(task) => {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
scheduler.resume_blocked_task_immediately(task);
|
|
||||||
}
|
|
||||||
None => {}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
match ret.process.spawn(self.uv_loop(), config, exit_cb) {
|
|
||||||
Ok(()) => {
|
|
||||||
// Only now do we actually get a handle to this scheduler.
|
|
||||||
ret.home = Some(get_handle_to_current_scheduler!());
|
|
||||||
Ok(ret)
|
|
||||||
}
|
|
||||||
Err(uverr) => {
|
|
||||||
// We still need to close the process handle we created, but
|
|
||||||
// that's taken care for us in the destructor of UvProcess
|
|
||||||
Err(uv_error_to_io_error(uverr))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct UvTcpListener {
|
pub struct UvTcpListener {
|
||||||
|
@ -737,7 +679,7 @@ impl RtioTcpListener for UvTcpListener {
|
||||||
uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 1 as c_int)
|
uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 1 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher(), r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -750,7 +692,7 @@ impl RtioTcpListener for UvTcpListener {
|
||||||
uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 0 as c_int)
|
uvll::tcp_simultaneous_accepts(self_.watcher().native_handle(), 0 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher(), r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -758,15 +700,40 @@ impl RtioTcpListener for UvTcpListener {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
trait UvStream: HomingIO {
|
pub struct UvTcpStream {
|
||||||
fn as_stream(&mut self) -> StreamWatcher;
|
watcher: TcpWatcher,
|
||||||
|
home: SchedHandle,
|
||||||
}
|
}
|
||||||
|
|
||||||
// FIXME(#3429) I would rather this be `impl<T: UvStream> RtioStream for T` but
|
impl HomingIO for UvTcpStream {
|
||||||
// that has conflicts with other traits that also have methods
|
fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
|
||||||
// called `read` and `write`
|
}
|
||||||
macro_rules! rtiostream(($t:ident) => {
|
|
||||||
impl RtioStream for $t {
|
impl Drop for UvTcpStream {
|
||||||
|
fn drop(&self) {
|
||||||
|
// XXX need mutable finalizer
|
||||||
|
let this = unsafe { transmute::<&UvTcpStream, &mut UvTcpStream>(self) };
|
||||||
|
do this.home_for_io_with_sched |self_, scheduler| {
|
||||||
|
do scheduler.deschedule_running_task_and_then |_, task| {
|
||||||
|
let task_cell = Cell::new(task);
|
||||||
|
do self_.watcher.as_stream().close {
|
||||||
|
let scheduler: ~Scheduler = Local::take();
|
||||||
|
scheduler.resume_blocked_task_immediately(task_cell.take());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RtioSocket for UvTcpStream {
|
||||||
|
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
|
||||||
|
do self.home_for_io |self_| {
|
||||||
|
socket_name(Tcp, self_.watcher)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RtioTcpStream for UvTcpStream {
|
||||||
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
|
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
|
||||||
do self.home_for_io_with_sched |self_, scheduler| {
|
do self.home_for_io_with_sched |self_, scheduler| {
|
||||||
let result_cell = Cell::new_empty();
|
let result_cell = Cell::new_empty();
|
||||||
|
@ -780,7 +747,7 @@ impl RtioStream for $t {
|
||||||
let alloc: AllocCallback = |_| unsafe {
|
let alloc: AllocCallback = |_| unsafe {
|
||||||
slice_to_uv_buf(*buf_ptr)
|
slice_to_uv_buf(*buf_ptr)
|
||||||
};
|
};
|
||||||
let mut watcher = self_.as_stream();
|
let mut watcher = self_.watcher.as_stream();
|
||||||
do watcher.read_start(alloc) |mut watcher, nread, _buf, status| {
|
do watcher.read_start(alloc) |mut watcher, nread, _buf, status| {
|
||||||
|
|
||||||
// Stop reading so that no read callbacks are
|
// Stop reading so that no read callbacks are
|
||||||
|
@ -816,7 +783,7 @@ impl RtioStream for $t {
|
||||||
do scheduler.deschedule_running_task_and_then |_, task| {
|
do scheduler.deschedule_running_task_and_then |_, task| {
|
||||||
let task_cell = Cell::new(task);
|
let task_cell = Cell::new(task);
|
||||||
let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
|
let buf = unsafe { slice_to_uv_buf(*buf_ptr) };
|
||||||
let mut watcher = self_.as_stream();
|
let mut watcher = self_.watcher.as_stream();
|
||||||
do watcher.write(buf) |_watcher, status| {
|
do watcher.write(buf) |_watcher, status| {
|
||||||
let result = if status.is_none() {
|
let result = if status.is_none() {
|
||||||
Ok(())
|
Ok(())
|
||||||
|
@ -835,85 +802,7 @@ impl RtioStream for $t {
|
||||||
result_cell.take()
|
result_cell.take()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
|
||||||
})
|
|
||||||
|
|
||||||
rtiostream!(UvPipeStream)
|
|
||||||
rtiostream!(UvTcpStream)
|
|
||||||
|
|
||||||
pub struct UvPipeStream {
|
|
||||||
pipe: Pipe,
|
|
||||||
home: SchedHandle,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl UvStream for UvPipeStream {
|
|
||||||
fn as_stream(&mut self) -> StreamWatcher { self.pipe.as_stream() }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl HomingIO for UvPipeStream {
|
|
||||||
fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for UvPipeStream {
|
|
||||||
fn drop(&self) {
|
|
||||||
// FIXME(#4330): should not need a transmute
|
|
||||||
let this = unsafe { cast::transmute_mut(self) };
|
|
||||||
do this.home_for_io |self_| {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
do scheduler.deschedule_running_task_and_then |_, task| {
|
|
||||||
let task_cell = Cell::new(task);
|
|
||||||
do self_.pipe.close {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
scheduler.resume_blocked_task_immediately(task_cell.take());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl UvPipeStream {
|
|
||||||
pub fn uv_pipe(&self) -> Pipe { self.pipe }
|
|
||||||
}
|
|
||||||
|
|
||||||
pub struct UvTcpStream {
|
|
||||||
watcher: TcpWatcher,
|
|
||||||
home: SchedHandle,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl HomingIO for UvTcpStream {
|
|
||||||
fn home<'r>(&'r mut self) -> &'r mut SchedHandle { &mut self.home }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for UvTcpStream {
|
|
||||||
fn drop(&self) {
|
|
||||||
// FIXME(#4330): should not need a transmute
|
|
||||||
let this = unsafe { cast::transmute_mut(self) };
|
|
||||||
do this.home_for_io |self_| {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
do scheduler.deschedule_running_task_and_then |_, task| {
|
|
||||||
let task_cell = Cell::new(task);
|
|
||||||
do self_.watcher.as_stream().close {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
scheduler.resume_blocked_task_immediately(task_cell.take());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl UvStream for UvTcpStream {
|
|
||||||
fn as_stream(&mut self) -> StreamWatcher { self.watcher.as_stream() }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RtioSocket for UvTcpStream {
|
|
||||||
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
|
|
||||||
do self.home_for_io |self_| {
|
|
||||||
socket_name(Tcp, self_.watcher)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RtioTcpStream for UvTcpStream {
|
|
||||||
fn peer_name(&mut self) -> Result<SocketAddr, IoError> {
|
fn peer_name(&mut self) -> Result<SocketAddr, IoError> {
|
||||||
do self.home_for_io |self_| {
|
do self.home_for_io |self_| {
|
||||||
socket_name(TcpPeer, self_.watcher)
|
socket_name(TcpPeer, self_.watcher)
|
||||||
|
@ -924,7 +813,7 @@ impl RtioTcpStream for UvTcpStream {
|
||||||
do self.home_for_io |self_| {
|
do self.home_for_io |self_| {
|
||||||
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 0 as c_int) };
|
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 0 as c_int) };
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -935,7 +824,7 @@ impl RtioTcpStream for UvTcpStream {
|
||||||
do self.home_for_io |self_| {
|
do self.home_for_io |self_| {
|
||||||
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 1 as c_int) };
|
let r = unsafe { uvll::tcp_nodelay(self_.watcher.native_handle(), 1 as c_int) };
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -949,7 +838,7 @@ impl RtioTcpStream for UvTcpStream {
|
||||||
delay_in_seconds as c_uint)
|
delay_in_seconds as c_uint)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -962,7 +851,7 @@ impl RtioTcpStream for UvTcpStream {
|
||||||
uvll::tcp_keepalive(self_.watcher.native_handle(), 0 as c_int, 0 as c_uint)
|
uvll::tcp_keepalive(self_.watcher.native_handle(), 0 as c_int, 0 as c_uint)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1074,7 +963,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1090,7 +979,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1104,7 +993,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 1 as c_int)
|
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 1 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1118,7 +1007,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 0 as c_int)
|
uvll::udp_set_multicast_loop(self_.watcher.native_handle(), 0 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1132,7 +1021,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_multicast_ttl(self_.watcher.native_handle(), ttl as c_int)
|
uvll::udp_set_multicast_ttl(self_.watcher.native_handle(), ttl as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1146,7 +1035,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_ttl(self_.watcher.native_handle(), ttl as c_int)
|
uvll::udp_set_ttl(self_.watcher.native_handle(), ttl as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1160,7 +1049,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_broadcast(self_.watcher.native_handle(), 1 as c_int)
|
uvll::udp_set_broadcast(self_.watcher.native_handle(), 1 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1174,7 +1063,7 @@ impl RtioUdpSocket for UvUdpSocket {
|
||||||
uvll::udp_set_broadcast(self_.watcher.native_handle(), 0 as c_int)
|
uvll::udp_set_broadcast(self_.watcher.native_handle(), 0 as c_int)
|
||||||
};
|
};
|
||||||
|
|
||||||
match status_to_maybe_uv_error(r) {
|
match status_to_maybe_uv_error(self_.watcher, r) {
|
||||||
Some(err) => Err(uv_error_to_io_error(err)),
|
Some(err) => Err(uv_error_to_io_error(err)),
|
||||||
None => Ok(())
|
None => Ok(())
|
||||||
}
|
}
|
||||||
|
@ -1361,89 +1250,6 @@ impl RtioFileStream for UvFileStream {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct UvProcess {
|
|
||||||
process: process::Process,
|
|
||||||
|
|
||||||
// Sadly, this structure must be created before we return it, so in that
|
|
||||||
// brief interim the `home` is None.
|
|
||||||
home: Option<SchedHandle>,
|
|
||||||
|
|
||||||
// All None until the process exits (exit_error may stay None)
|
|
||||||
priv exit_status: Option<int>,
|
|
||||||
priv term_signal: Option<int>,
|
|
||||||
priv exit_error: Option<UvError>,
|
|
||||||
|
|
||||||
// Used to store which task to wake up from the exit_cb
|
|
||||||
priv descheduled: Option<BlockedTask>,
|
|
||||||
}
|
|
||||||
|
|
||||||
impl HomingIO for UvProcess {
|
|
||||||
fn home<'r>(&'r mut self) -> &'r mut SchedHandle { self.home.get_mut_ref() }
|
|
||||||
}
|
|
||||||
|
|
||||||
impl Drop for UvProcess {
|
|
||||||
fn drop(&self) {
|
|
||||||
// FIXME(#4330): should not need a transmute
|
|
||||||
let this = unsafe { cast::transmute_mut(self) };
|
|
||||||
|
|
||||||
let close = |self_: &mut UvProcess| {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
do scheduler.deschedule_running_task_and_then |_, task| {
|
|
||||||
let task = Cell::new(task);
|
|
||||||
do self_.process.close {
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
scheduler.resume_blocked_task_immediately(task.take());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
// If home is none, then this process never actually successfully
|
|
||||||
// spawned, so there's no need to switch event loops
|
|
||||||
if this.home.is_none() {
|
|
||||||
close(this)
|
|
||||||
} else {
|
|
||||||
this.home_for_io(close)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
impl RtioProcess for UvProcess {
|
|
||||||
fn id(&self) -> pid_t {
|
|
||||||
self.process.pid()
|
|
||||||
}
|
|
||||||
|
|
||||||
fn kill(&mut self, signal: int) -> Result<(), IoError> {
|
|
||||||
do self.home_for_io |self_| {
|
|
||||||
match self_.process.kill(signal) {
|
|
||||||
Ok(()) => Ok(()),
|
|
||||||
Err(uverr) => Err(uv_error_to_io_error(uverr))
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
fn wait(&mut self) -> int {
|
|
||||||
// Make sure (on the home scheduler) that we have an exit status listed
|
|
||||||
do self.home_for_io |self_| {
|
|
||||||
match self_.exit_status {
|
|
||||||
Some(*) => {}
|
|
||||||
None => {
|
|
||||||
// If there's no exit code previously listed, then the
|
|
||||||
// process's exit callback has yet to be invoked. We just
|
|
||||||
// need to deschedule ourselves and wait to be reawoken.
|
|
||||||
let scheduler: ~Scheduler = Local::take();
|
|
||||||
do scheduler.deschedule_running_task_and_then |_, task| {
|
|
||||||
assert!(self_.descheduled.is_none());
|
|
||||||
self_.descheduled = Some(task);
|
|
||||||
}
|
|
||||||
assert!(self_.exit_status.is_some());
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
self.exit_status.unwrap()
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_simple_io_no_connect() {
|
fn test_simple_io_no_connect() {
|
||||||
do run_in_newsched_task {
|
do run_in_newsched_task {
|
||||||
|
|
|
@ -37,74 +37,28 @@ use libc::{malloc, free};
|
||||||
use libc;
|
use libc;
|
||||||
use prelude::*;
|
use prelude::*;
|
||||||
use ptr;
|
use ptr;
|
||||||
|
use str;
|
||||||
use vec;
|
use vec;
|
||||||
|
|
||||||
pub use self::errors::*;
|
pub static UNKNOWN: c_int = -1;
|
||||||
|
|
||||||
pub static OK: c_int = 0;
|
pub static OK: c_int = 0;
|
||||||
pub static EOF: c_int = -4095;
|
pub static EOF: c_int = 1;
|
||||||
pub static UNKNOWN: c_int = -4094;
|
pub static EADDRINFO: c_int = 2;
|
||||||
|
pub static EACCES: c_int = 3;
|
||||||
|
pub static ECONNREFUSED: c_int = 12;
|
||||||
|
pub static ECONNRESET: c_int = 13;
|
||||||
|
pub static EPIPE: c_int = 36;
|
||||||
|
|
||||||
// uv-errno.h redefines error codes for windows, but not for unix...
|
pub struct uv_err_t {
|
||||||
|
code: c_int,
|
||||||
#[cfg(windows)]
|
sys_errno_: c_int
|
||||||
pub mod errors {
|
|
||||||
use libc::c_int;
|
|
||||||
|
|
||||||
pub static EACCES: c_int = -4093;
|
|
||||||
pub static ECONNREFUSED: c_int = -4079;
|
|
||||||
pub static ECONNRESET: c_int = -4078;
|
|
||||||
pub static EPIPE: c_int = -4048;
|
|
||||||
}
|
}
|
||||||
#[cfg(not(windows))]
|
|
||||||
pub mod errors {
|
|
||||||
use libc;
|
|
||||||
use libc::c_int;
|
|
||||||
|
|
||||||
pub static EACCES: c_int = -libc::EACCES;
|
|
||||||
pub static ECONNREFUSED: c_int = -libc::ECONNREFUSED;
|
|
||||||
pub static ECONNRESET: c_int = -libc::ECONNRESET;
|
|
||||||
pub static EPIPE: c_int = -libc::EPIPE;
|
|
||||||
}
|
|
||||||
|
|
||||||
pub static PROCESS_SETUID: c_int = 1 << 0;
|
|
||||||
pub static PROCESS_SETGID: c_int = 1 << 1;
|
|
||||||
pub static PROCESS_WINDOWS_VERBATIM_ARGUMENTS: c_int = 1 << 2;
|
|
||||||
pub static PROCESS_DETACHED: c_int = 1 << 3;
|
|
||||||
pub static PROCESS_WINDOWS_HIDE: c_int = 1 << 4;
|
|
||||||
|
|
||||||
pub static STDIO_IGNORE: c_int = 0x00;
|
|
||||||
pub static STDIO_CREATE_PIPE: c_int = 0x01;
|
|
||||||
pub static STDIO_INHERIT_FD: c_int = 0x02;
|
|
||||||
pub static STDIO_INHERIT_STREAM: c_int = 0x04;
|
|
||||||
pub static STDIO_READABLE_PIPE: c_int = 0x10;
|
|
||||||
pub static STDIO_WRITABLE_PIPE: c_int = 0x20;
|
|
||||||
|
|
||||||
pub struct uv_buf_t {
|
pub struct uv_buf_t {
|
||||||
base: *u8,
|
base: *u8,
|
||||||
len: libc::size_t,
|
len: libc::size_t,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct uv_process_options_t {
|
|
||||||
exit_cb: uv_exit_cb,
|
|
||||||
file: *libc::c_char,
|
|
||||||
args: **libc::c_char,
|
|
||||||
env: **libc::c_char,
|
|
||||||
cwd: *libc::c_char,
|
|
||||||
flags: libc::c_uint,
|
|
||||||
stdio_count: libc::c_int,
|
|
||||||
stdio: *uv_stdio_container_t,
|
|
||||||
uid: uv_uid_t,
|
|
||||||
gid: uv_gid_t,
|
|
||||||
}
|
|
||||||
|
|
||||||
// These fields are private because they must be interfaced with through the
|
|
||||||
// functions below.
|
|
||||||
pub struct uv_stdio_container_t {
|
|
||||||
priv flags: libc::c_int,
|
|
||||||
priv stream: *uv_stream_t,
|
|
||||||
}
|
|
||||||
|
|
||||||
pub type uv_handle_t = c_void;
|
pub type uv_handle_t = c_void;
|
||||||
pub type uv_loop_t = c_void;
|
pub type uv_loop_t = c_void;
|
||||||
pub type uv_idle_t = c_void;
|
pub type uv_idle_t = c_void;
|
||||||
|
@ -118,8 +72,6 @@ pub type uv_timer_t = c_void;
|
||||||
pub type uv_stream_t = c_void;
|
pub type uv_stream_t = c_void;
|
||||||
pub type uv_fs_t = c_void;
|
pub type uv_fs_t = c_void;
|
||||||
pub type uv_udp_send_t = c_void;
|
pub type uv_udp_send_t = c_void;
|
||||||
pub type uv_process_t = c_void;
|
|
||||||
pub type uv_pipe_t = c_void;
|
|
||||||
|
|
||||||
#[cfg(stage0)]
|
#[cfg(stage0)]
|
||||||
pub type uv_idle_cb = *u8;
|
pub type uv_idle_cb = *u8;
|
||||||
|
@ -145,8 +97,6 @@ pub type uv_connection_cb = *u8;
|
||||||
pub type uv_timer_cb = *u8;
|
pub type uv_timer_cb = *u8;
|
||||||
#[cfg(stage0)]
|
#[cfg(stage0)]
|
||||||
pub type uv_write_cb = *u8;
|
pub type uv_write_cb = *u8;
|
||||||
#[cfg(stage0)]
|
|
||||||
pub type uv_exit_cb = *u8;
|
|
||||||
|
|
||||||
#[cfg(not(stage0))]
|
#[cfg(not(stage0))]
|
||||||
pub type uv_idle_cb = extern "C" fn(handle: *uv_idle_t,
|
pub type uv_idle_cb = extern "C" fn(handle: *uv_idle_t,
|
||||||
|
@ -187,21 +137,12 @@ pub type uv_timer_cb = extern "C" fn(handle: *uv_timer_t,
|
||||||
#[cfg(not(stage0))]
|
#[cfg(not(stage0))]
|
||||||
pub type uv_write_cb = extern "C" fn(handle: *uv_write_t,
|
pub type uv_write_cb = extern "C" fn(handle: *uv_write_t,
|
||||||
status: c_int);
|
status: c_int);
|
||||||
#[cfg(not(stage0))]
|
|
||||||
pub type uv_exit_cb = extern "C" fn(handle: *uv_process_t,
|
|
||||||
exit_status: c_int,
|
|
||||||
term_signal: c_int);
|
|
||||||
|
|
||||||
pub type sockaddr = c_void;
|
pub type sockaddr = c_void;
|
||||||
pub type sockaddr_in = c_void;
|
pub type sockaddr_in = c_void;
|
||||||
pub type sockaddr_in6 = c_void;
|
pub type sockaddr_in6 = c_void;
|
||||||
pub type sockaddr_storage = c_void;
|
pub type sockaddr_storage = c_void;
|
||||||
|
|
||||||
#[cfg(unix)] pub type uv_uid_t = libc::types::os::arch::posix88::uid_t;
|
|
||||||
#[cfg(unix)] pub type uv_gid_t = libc::types::os::arch::posix88::gid_t;
|
|
||||||
#[cfg(windows)] pub type uv_uid_t = libc::c_uchar;
|
|
||||||
#[cfg(windows)] pub type uv_gid_t = libc::c_uchar;
|
|
||||||
|
|
||||||
#[deriving(Eq)]
|
#[deriving(Eq)]
|
||||||
pub enum uv_handle_type {
|
pub enum uv_handle_type {
|
||||||
UV_UNKNOWN_HANDLE,
|
UV_UNKNOWN_HANDLE,
|
||||||
|
@ -546,12 +487,20 @@ pub unsafe fn read_stop(stream: *uv_stream_t) -> c_int {
|
||||||
return rust_uv_read_stop(stream as *c_void);
|
return rust_uv_read_stop(stream as *c_void);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub unsafe fn strerror(err: c_int) -> *c_char {
|
pub unsafe fn last_error(loop_handle: *c_void) -> uv_err_t {
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
#[fixed_stack_segment]; #[inline(never)];
|
||||||
|
|
||||||
|
return rust_uv_last_error(loop_handle);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn strerror(err: *uv_err_t) -> *c_char {
|
||||||
|
#[fixed_stack_segment]; #[inline(never)];
|
||||||
|
|
||||||
return rust_uv_strerror(err);
|
return rust_uv_strerror(err);
|
||||||
}
|
}
|
||||||
pub unsafe fn err_name(err: c_int) -> *c_char {
|
pub unsafe fn err_name(err: *uv_err_t) -> *c_char {
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
#[fixed_stack_segment]; #[inline(never)];
|
||||||
|
|
||||||
return rust_uv_err_name(err);
|
return rust_uv_err_name(err);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -705,45 +654,6 @@ pub unsafe fn fs_req_cleanup(req: *uv_fs_t) {
|
||||||
rust_uv_fs_req_cleanup(req);
|
rust_uv_fs_req_cleanup(req);
|
||||||
}
|
}
|
||||||
|
|
||||||
pub unsafe fn spawn(loop_ptr: *c_void, result: *uv_process_t,
|
|
||||||
options: uv_process_options_t) -> c_int {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
return rust_uv_spawn(loop_ptr, result, options);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn process_kill(p: *uv_process_t, signum: c_int) -> c_int {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
return rust_uv_process_kill(p, signum);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn process_pid(p: *uv_process_t) -> c_int {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
return rust_uv_process_pid(p);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn set_stdio_container_flags(c: *uv_stdio_container_t,
|
|
||||||
flags: libc::c_int) {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
rust_set_stdio_container_flags(c, flags);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn set_stdio_container_fd(c: *uv_stdio_container_t,
|
|
||||||
fd: libc::c_int) {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
rust_set_stdio_container_fd(c, fd);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn set_stdio_container_stream(c: *uv_stdio_container_t,
|
|
||||||
stream: *uv_stream_t) {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
rust_set_stdio_container_stream(c, stream);
|
|
||||||
}
|
|
||||||
|
|
||||||
pub unsafe fn pipe_init(loop_ptr: *c_void, p: *uv_pipe_t, ipc: c_int) -> c_int {
|
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
|
||||||
rust_uv_pipe_init(loop_ptr, p, ipc)
|
|
||||||
}
|
|
||||||
|
|
||||||
// data access helpers
|
// data access helpers
|
||||||
pub unsafe fn get_result_from_fs_req(req: *uv_fs_t) -> c_int {
|
pub unsafe fn get_result_from_fs_req(req: *uv_fs_t) -> c_int {
|
||||||
#[fixed_stack_segment]; #[inline(never)];
|
#[fixed_stack_segment]; #[inline(never)];
|
||||||
|
@ -810,6 +720,22 @@ pub unsafe fn get_len_from_buf(buf: uv_buf_t) -> size_t {
|
||||||
|
|
||||||
return rust_uv_get_len_from_buf(buf);
|
return rust_uv_get_len_from_buf(buf);
|
||||||
}
|
}
|
||||||
|
pub unsafe fn get_last_err_info(uv_loop: *c_void) -> ~str {
|
||||||
|
let err = last_error(uv_loop);
|
||||||
|
let err_ptr = ptr::to_unsafe_ptr(&err);
|
||||||
|
let err_name = str::raw::from_c_str(err_name(err_ptr));
|
||||||
|
let err_msg = str::raw::from_c_str(strerror(err_ptr));
|
||||||
|
return fmt!("LIBUV ERROR: name: %s msg: %s",
|
||||||
|
err_name, err_msg);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn get_last_err_data(uv_loop: *c_void) -> uv_err_data {
|
||||||
|
let err = last_error(uv_loop);
|
||||||
|
let err_ptr = ptr::to_unsafe_ptr(&err);
|
||||||
|
let err_name = str::raw::from_c_str(err_name(err_ptr));
|
||||||
|
let err_msg = str::raw::from_c_str(strerror(err_ptr));
|
||||||
|
uv_err_data { err_name: err_name, err_msg: err_msg }
|
||||||
|
}
|
||||||
|
|
||||||
pub struct uv_err_data {
|
pub struct uv_err_data {
|
||||||
err_name: ~str,
|
err_name: ~str,
|
||||||
|
@ -842,8 +768,9 @@ extern {
|
||||||
cb: uv_async_cb) -> c_int;
|
cb: uv_async_cb) -> c_int;
|
||||||
fn rust_uv_tcp_init(loop_handle: *c_void, handle_ptr: *uv_tcp_t) -> c_int;
|
fn rust_uv_tcp_init(loop_handle: *c_void, handle_ptr: *uv_tcp_t) -> c_int;
|
||||||
fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8, len: size_t);
|
fn rust_uv_buf_init(out_buf: *uv_buf_t, base: *u8, len: size_t);
|
||||||
fn rust_uv_strerror(err: c_int) -> *c_char;
|
fn rust_uv_last_error(loop_handle: *c_void) -> uv_err_t;
|
||||||
fn rust_uv_err_name(err: c_int) -> *c_char;
|
fn rust_uv_strerror(err: *uv_err_t) -> *c_char;
|
||||||
|
fn rust_uv_err_name(err: *uv_err_t) -> *c_char;
|
||||||
fn rust_uv_ip4_addrp(ip: *u8, port: c_int) -> *sockaddr_in;
|
fn rust_uv_ip4_addrp(ip: *u8, port: c_int) -> *sockaddr_in;
|
||||||
fn rust_uv_ip6_addrp(ip: *u8, port: c_int) -> *sockaddr_in6;
|
fn rust_uv_ip6_addrp(ip: *u8, port: c_int) -> *sockaddr_in6;
|
||||||
fn rust_uv_free_ip4_addr(addr: *sockaddr_in);
|
fn rust_uv_free_ip4_addr(addr: *sockaddr_in);
|
||||||
|
@ -929,13 +856,4 @@ extern {
|
||||||
fn rust_uv_set_data_for_req(req: *c_void, data: *c_void);
|
fn rust_uv_set_data_for_req(req: *c_void, data: *c_void);
|
||||||
fn rust_uv_get_base_from_buf(buf: uv_buf_t) -> *u8;
|
fn rust_uv_get_base_from_buf(buf: uv_buf_t) -> *u8;
|
||||||
fn rust_uv_get_len_from_buf(buf: uv_buf_t) -> size_t;
|
fn rust_uv_get_len_from_buf(buf: uv_buf_t) -> size_t;
|
||||||
fn rust_uv_spawn(loop_ptr: *c_void, outptr: *uv_process_t,
|
|
||||||
options: uv_process_options_t) -> c_int;
|
|
||||||
fn rust_uv_process_kill(p: *uv_process_t, signum: c_int) -> c_int;
|
|
||||||
fn rust_uv_process_pid(p: *uv_process_t) -> c_int;
|
|
||||||
fn rust_set_stdio_container_flags(c: *uv_stdio_container_t, flags: c_int);
|
|
||||||
fn rust_set_stdio_container_fd(c: *uv_stdio_container_t, fd: c_int);
|
|
||||||
fn rust_set_stdio_container_stream(c: *uv_stdio_container_t,
|
|
||||||
stream: *uv_stream_t);
|
|
||||||
fn rust_uv_pipe_init(loop_ptr: *c_void, p: *uv_pipe_t, ipc: c_int) -> c_int;
|
|
||||||
}
|
}
|
||||||
|
|
1107
src/libstd/run.rs
1107
src/libstd/run.rs
File diff suppressed because it is too large
Load Diff
|
@ -1 +1 @@
|
||||||
Subproject commit d88cf5652a1afb23939da0bae86c70ec521b9921
|
Subproject commit dfae9c3e958dc086d9c0ab068cd76d196c95a433
|
|
@ -329,13 +329,20 @@ rust_uv_get_len_from_buf(uv_buf_t buf) {
|
||||||
return buf.len;
|
return buf.len;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
extern "C" uv_err_t
|
||||||
|
rust_uv_last_error(uv_loop_t* loop) {
|
||||||
|
return uv_last_error(loop);
|
||||||
|
}
|
||||||
|
|
||||||
extern "C" const char*
|
extern "C" const char*
|
||||||
rust_uv_strerror(int err) {
|
rust_uv_strerror(uv_err_t* err_ptr) {
|
||||||
|
uv_err_t err = *err_ptr;
|
||||||
return uv_strerror(err);
|
return uv_strerror(err);
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "C" const char*
|
extern "C" const char*
|
||||||
rust_uv_err_name(int err) {
|
rust_uv_err_name(uv_err_t* err_ptr) {
|
||||||
|
uv_err_t err = *err_ptr;
|
||||||
return uv_err_name(err);
|
return uv_err_name(err);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -546,37 +553,3 @@ extern "C" uv_loop_t*
|
||||||
rust_uv_get_loop_from_fs_req(uv_fs_t* req) {
|
rust_uv_get_loop_from_fs_req(uv_fs_t* req) {
|
||||||
return req->loop;
|
return req->loop;
|
||||||
}
|
}
|
||||||
extern "C" int
|
|
||||||
rust_uv_spawn(uv_loop_t *loop, uv_process_t *p, uv_process_options_t options) {
|
|
||||||
return uv_spawn(loop, p, options);
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" int
|
|
||||||
rust_uv_process_kill(uv_process_t *p, int signum) {
|
|
||||||
return uv_process_kill(p, signum);
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" void
|
|
||||||
rust_set_stdio_container_flags(uv_stdio_container_t *c, int flags) {
|
|
||||||
c->flags = (uv_stdio_flags) flags;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" void
|
|
||||||
rust_set_stdio_container_fd(uv_stdio_container_t *c, int fd) {
|
|
||||||
c->data.fd = fd;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" void
|
|
||||||
rust_set_stdio_container_stream(uv_stdio_container_t *c, uv_stream_t *stream) {
|
|
||||||
c->data.stream = stream;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" int
|
|
||||||
rust_uv_process_pid(uv_process_t* p) {
|
|
||||||
return p->pid;
|
|
||||||
}
|
|
||||||
|
|
||||||
extern "C" int
|
|
||||||
rust_uv_pipe_init(uv_loop_t *loop, uv_pipe_t* p, int ipc) {
|
|
||||||
return uv_pipe_init(loop, p, ipc);
|
|
||||||
}
|
|
||||||
|
|
|
@ -47,6 +47,7 @@ rust_uv_timer_start
|
||||||
rust_uv_timer_stop
|
rust_uv_timer_stop
|
||||||
rust_uv_tcp_init
|
rust_uv_tcp_init
|
||||||
rust_uv_buf_init
|
rust_uv_buf_init
|
||||||
|
rust_uv_last_error
|
||||||
rust_uv_strerror
|
rust_uv_strerror
|
||||||
rust_uv_err_name
|
rust_uv_err_name
|
||||||
rust_uv_ip4_addr
|
rust_uv_ip4_addr
|
||||||
|
@ -190,11 +191,4 @@ rust_drop_global_args_lock
|
||||||
rust_take_change_dir_lock
|
rust_take_change_dir_lock
|
||||||
rust_drop_change_dir_lock
|
rust_drop_change_dir_lock
|
||||||
rust_get_test_int
|
rust_get_test_int
|
||||||
rust_get_task
|
rust_get_task
|
||||||
rust_uv_spawn
|
|
||||||
rust_uv_process_kill
|
|
||||||
rust_set_stdio_container_flags
|
|
||||||
rust_set_stdio_container_fd
|
|
||||||
rust_set_stdio_container_stream
|
|
||||||
rust_uv_process_pid
|
|
||||||
rust_uv_pipe_init
|
|
|
@ -22,15 +22,13 @@ use std::str;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_destroy_once() {
|
fn test_destroy_once() {
|
||||||
let p = run::Process::new("echo", [], run::ProcessOptions::new());
|
let mut p = run::Process::new("echo", [], run::ProcessOptions::new());
|
||||||
let mut p = p.unwrap();
|
|
||||||
p.destroy(); // this shouldn't crash (and nor should the destructor)
|
p.destroy(); // this shouldn't crash (and nor should the destructor)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_destroy_twice() {
|
fn test_destroy_twice() {
|
||||||
let p = run::Process::new("echo", [], run::ProcessOptions::new());
|
let mut p = run::Process::new("echo", [], run::ProcessOptions::new());
|
||||||
let mut p = p.unwrap();
|
|
||||||
p.destroy(); // this shouldnt crash...
|
p.destroy(); // this shouldnt crash...
|
||||||
p.destroy(); // ...and nor should this (and nor should the destructor)
|
p.destroy(); // ...and nor should this (and nor should the destructor)
|
||||||
}
|
}
|
||||||
|
@ -76,8 +74,7 @@ fn test_destroy_actually_kills(force: bool) {
|
||||||
}
|
}
|
||||||
|
|
||||||
// this process will stay alive indefinitely trying to read from stdin
|
// this process will stay alive indefinitely trying to read from stdin
|
||||||
let p = run::Process::new(BLOCK_COMMAND, [], run::ProcessOptions::new());
|
let mut p = run::Process::new(BLOCK_COMMAND, [], run::ProcessOptions::new());
|
||||||
let mut p = p.unwrap();
|
|
||||||
|
|
||||||
assert!(process_exists(p.get_id()));
|
assert!(process_exists(p.get_id()));
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue