bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

std: Stop using oldcomm

Browse source
This commit is contained in:
Brian Anderson 2013-01-25 00:52:50 -08:00
parent 87acde8826
commit da4b376897
8 changed files with 427 additions and 447 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/libstd/arc.rs
View file

@ -483,7 +483,6 @@ mod tests {
use arc::*;
use arc;
use core::oldcomm::*;
use core::option::{Some, None};
use core::option;
use core::pipes;

1
src/libstd/c_vec.rs
View file

@ -38,7 +38,6 @@
#[forbid(deprecated_mode)];
use core::libc;
use core::oldcomm;
use core::option;
use core::prelude::*;
use core::ptr;

71
src/libstd/net_ip.rs
View file

@ -12,8 +12,8 @@
#[forbid(deprecated_mode)];
use core::libc;
use core::oldcomm;
use core::prelude::*;
use core::pipes::{stream, SharedChan};
use core::ptr;
use core::result;
use core::str;
@ -113,40 +113,40 @@ enum IpGetAddrErr {
* A `result<~[ip_addr], ip_get_addr_err>` instance that will contain
* a vector of `ip_addr` results, in the case of success, or an error
* object in the case of failure
*/
*/
pub fn get_addr(node: &str, iotask: &iotask)
-> result::Result<~[IpAddr], IpGetAddrErr> {
do oldcomm::listen |output_ch| {
do str::as_buf(node) |node_ptr, len| {
unsafe {
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
let handle_ptr = ptr::addr_of(&handle);
let handle_data = GetAddrData {
output_ch: output_ch
};
let handle_data_ptr = ptr::addr_of(&handle_data);
do interact(iotask) |loop_ptr| {
unsafe {
let result = uv_getaddrinfo(
loop_ptr,
handle_ptr,
get_addr_cb,
node_ptr,
ptr::null(),
ptr::null());
match result {
0i32 => {
-> result::Result<~[IpAddr], IpGetAddrErr> {
let (output_po, output_ch) = stream();
let output_ch = SharedChan(output_ch);
do str::as_buf(node) |node_ptr, len| {
unsafe {
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
let handle_ptr = ptr::addr_of(&handle);
let handle_data = GetAddrData {
output_ch: output_ch.clone()
};
let handle_data_ptr = ptr::addr_of(&handle_data);
do interact(iotask) |loop_ptr| {
unsafe {
let result = uv_getaddrinfo(
loop_ptr,
handle_ptr,
get_addr_cb,
node_ptr,
ptr::null(),
ptr::null());
match result {
0i32 => {
set_data_for_req(handle_ptr, handle_data_ptr);
}
_ => {
}
_ => {
output_ch.send(result::Err(GetAddrUnknownError));
}
}
}
};
output_ch.recv()
}
}
};
output_po.recv()
}
}
}
@ -300,7 +300,7 @@ pub mod v6 {
}
struct GetAddrData {
output_ch: oldcomm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
output_ch: SharedChan<result::Result<~[IpAddr],IpGetAddrErr>>
}
extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
@ -309,6 +309,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
log(debug, ~"in get_addr_cb");
let handle_data = get_data_for_req(handle) as
*GetAddrData;
let output_ch = (*handle_data).output_ch.clone();
if status == 0i32 {
if res != (ptr::null::<addrinfo>()) {
let mut out_vec = ~[];
@ -326,7 +327,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
else {
log(debug, ~"curr_addr is not of family AF_INET or "+
~"AF_INET6. Error.");
(*handle_data).output_ch.send(
output_ch.send(
result::Err(GetAddrUnknownError));
break;
};
@ -344,17 +345,17 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
}
log(debug, fmt!("successful process addrinfo result, len: %?",
vec::len(out_vec)));
(*handle_data).output_ch.send(result::Ok(move out_vec));
output_ch.send(result::Ok(move out_vec));
}
else {
log(debug, ~"addrinfo pointer is NULL");
(*handle_data).output_ch.send(
output_ch.send(
result::Err(GetAddrUnknownError));
}
}
else {
log(debug, ~"status != 0 error in get_addr_cb");
(*handle_data).output_ch.send(
output_ch.send(
result::Err(GetAddrUnknownError));
}
if res != (ptr::null::<addrinfo>()) {

575
src/libstd/net_tcp.rs
View file

File diff suppressed because it is too large Load diff

42
src/libstd/test.rs
View file

@ -27,7 +27,7 @@ use core::either;
use core::io::WriterUtil;
use core::io;
use core::libc::size_t;
use core::oldcomm;
use core::pipes::{stream, Chan, Port, SharedChan};
use core::option;
use core::prelude::*;
use core::result;
@ -305,8 +305,8 @@ fn run_tests(opts: &TestOpts,
let mut wait_idx = 0;
let mut done_idx = 0;
let p = oldcomm::Port();
let ch = oldcomm::Chan(&p);
let (p, ch) = stream();
let ch = SharedChan(ch);
while done_idx < total {
while wait_idx < concurrency && run_idx < total {
@ -317,12 +317,12 @@ fn run_tests(opts: &TestOpts,
// that hang forever.
callback(TeWait(copy test));
}
run_test(move test, ch);
run_test(move test, ch.clone());
wait_idx += 1;
run_idx += 1;
}
let (test, result) = oldcomm::recv(p);
let (test, result) = p.recv();
if concurrency != 1 {
callback(TeWait(copy test));
}
@ -406,9 +406,9 @@ struct TestFuture {
wait: fn@() -> TestResult,
}
pub fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
pub fn run_test(test: TestDesc, monitor_ch: SharedChan<MonitorMsg>) {
if test.ignore {
oldcomm::send(monitor_ch, (copy test, TrIgnored));
monitor_ch.send((copy test, TrIgnored));
return;
}
@ -420,7 +420,7 @@ pub fn run_test(test: TestDesc, monitor_ch: oldcomm::Chan<MonitorMsg>) {
}).spawn(move testfn);
let task_result = option::unwrap(move result_future).recv();
let test_result = calc_result(&test, task_result == task::Success);
oldcomm::send(monitor_ch, (copy test, test_result));
monitor_ch.send((copy test, test_result));
};
}
@ -440,7 +440,7 @@ mod tests {
use test::{TestOpts, run_test};
use core::either;
use core::oldcomm;
use core::pipes::{stream, SharedChan};
use core::option;
use core::vec;
@ -453,10 +453,10 @@ mod tests {
ignore: true,
should_fail: false
};
let p = oldcomm::Port();
let ch = oldcomm::Chan(&p);
let (p, ch) = stream();
let ch = SharedChan(ch);
run_test(desc, ch);
let (_, res) = oldcomm::recv(p);
let (_, res) = p.recv();
assert res != TrOk;
}
@ -469,10 +469,10 @@ mod tests {
ignore: true,
should_fail: false
};
let p = oldcomm::Port();
let ch = oldcomm::Chan(&p);
let (p, ch) = stream();
let ch = SharedChan(ch);
run_test(desc, ch);
let (_, res) = oldcomm::recv(p);
let (_, res) = p.recv();
assert res == TrIgnored;
}
@ -486,10 +486,10 @@ mod tests {
ignore: false,
should_fail: true
};
let p = oldcomm::Port();
let ch = oldcomm::Chan(&p);
let (p, ch) = stream();
let ch = SharedChan(ch);
run_test(desc, ch);
let (_, res) = oldcomm::recv(p);
let (_, res) = p.recv();
assert res == TrOk;
}
@ -502,10 +502,10 @@ mod tests {
ignore: false,
should_fail: true
};
let p = oldcomm::Port();
let ch = oldcomm::Chan(&p);
let (p, ch) = stream();
let ch = SharedChan(ch);
run_test(desc, ch);
let (_, res) = oldcomm::recv(p);
let (_, res) = p.recv();
assert res == TrFailed;
}

91
src/libstd/timer.rs
View file

@ -18,7 +18,9 @@ use uv::iotask::IoTask;
use core::either;
use core::libc;
use core::oldcomm;
use core::libc::c_void;
use core::cast::transmute;
use core::pipes::{stream, Chan, SharedChan, Port, select2i};
use core::prelude::*;
use core::ptr;
use core;
@ -41,12 +43,11 @@ use core;
*/
pub fn delayed_send<T: Owned>(iotask: &IoTask,
msecs: uint,
ch: oldcomm::Chan<T>,
ch: &Chan<T>,
val: T) {
unsafe {
let timer_done_po = oldcomm::Port::<()>();
let timer_done_ch = oldcomm::Chan(&timer_done_po);
let timer_done_ch_ptr = ptr::addr_of(&timer_done_ch);
let (timer_done_po, timer_done_ch) = stream::<()>();
let timer_done_ch = SharedChan(timer_done_ch);
let timer = uv::ll::timer_t();
let timer_ptr = ptr::addr_of(&timer);
do iotask::interact(iotask) |loop_ptr| {
@ -56,9 +57,15 @@ pub fn delayed_send<T: Owned>(iotask: &IoTask,
let start_result = uv::ll::timer_start(
timer_ptr, delayed_send_cb, msecs, 0u);
if (start_result == 0i32) {
// Note: putting the channel into a ~
// to cast to *c_void
let timer_done_ch_clone = ~timer_done_ch.clone();
let timer_done_ch_ptr = transmute::<
~SharedChan<()>, *c_void>(
timer_done_ch_clone);
uv::ll::set_data_for_uv_handle(
timer_ptr,
timer_done_ch_ptr as *libc::c_void);
timer_done_ch_ptr);
} else {
let error_msg = uv::ll::get_last_err_info(
loop_ptr);
@ -73,11 +80,11 @@ pub fn delayed_send<T: Owned>(iotask: &IoTask,
}
};
// delayed_send_cb has been processed by libuv
oldcomm::recv(timer_done_po);
timer_done_po.recv();
// notify the caller immediately
oldcomm::send(ch, move(val));
ch.send(val);
// uv_close for this timer has been processed
oldcomm::recv(timer_done_po);
timer_done_po.recv();
};
}
@ -93,10 +100,9 @@ pub fn delayed_send<T: Owned>(iotask: &IoTask,
* * msecs - an amount of time, in milliseconds, for the current task to block
*/
pub fn sleep(iotask: &IoTask, msecs: uint) {
let exit_po = oldcomm::Port::<()>();
let exit_ch = oldcomm::Chan(&exit_po);
delayed_send(iotask, msecs, exit_ch, ());
oldcomm::recv(exit_po);
let (exit_po, exit_ch) = stream::<()>();
delayed_send(iotask, msecs, &exit_ch, ());
exit_po.recv();
}
/**
@ -121,20 +127,17 @@ pub fn sleep(iotask: &IoTask, msecs: uint) {
*/
pub fn recv_timeout<T: Copy Owned>(iotask: &IoTask,
msecs: uint,
wait_po: oldcomm::Port<T>)
wait_po: &Port<T>)
-> Option<T> {
let timeout_po = oldcomm::Port::<()>();
let timeout_ch = oldcomm::Chan(&timeout_po);
delayed_send(iotask, msecs, timeout_ch, ());
let (timeout_po, timeout_ch) = stream::<()>();
delayed_send(iotask, msecs, &timeout_ch, ());
// FIXME: This could be written clearer (#2618)
either::either(
|left_val| {
log(debug, fmt!("recv_time .. left_val %?",
left_val));
|_| {
None
}, |right_val| {
Some(*right_val)
}, &oldcomm::select2(timeout_po, wait_po)
}, |_| {
Some(wait_po.recv())
}, &select2i(&timeout_po, wait_po)
)
}
@ -144,11 +147,14 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
unsafe {
log(debug,
fmt!("delayed_send_cb handle %? status %?", handle, status));
let timer_done_ch =
*(uv::ll::get_data_for_uv_handle(handle) as *oldcomm::Chan<()>);
// Faking a borrowed pointer to our ~SharedChan
let timer_done_ch_ptr: &*c_void = &uv::ll::get_data_for_uv_handle(
handle);
let timer_done_ch_ptr = transmute::<&*c_void, &~SharedChan<()>>(
timer_done_ch_ptr);
let stop_result = uv::ll::timer_stop(handle);
if (stop_result == 0i32) {
oldcomm::send(timer_done_ch, ());
timer_done_ch_ptr.send(());
uv::ll::close(handle, delayed_send_close_cb);
} else {
let loop_ptr = uv::ll::get_loop_for_uv_handle(handle);
@ -161,9 +167,10 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) {
unsafe {
log(debug, fmt!("delayed_send_close_cb handle %?", handle));
let timer_done_ch =
*(uv::ll::get_data_for_uv_handle(handle) as *oldcomm::Chan<()>);
oldcomm::send(timer_done_ch, ());
let timer_done_ch_ptr = uv::ll::get_data_for_uv_handle(handle);
let timer_done_ch = transmute::<*c_void, ~SharedChan<()>>(
timer_done_ch_ptr);
timer_done_ch.send(());
}
}
@ -175,9 +182,9 @@ mod test {
use uv;
use core::iter;
use core::oldcomm;
use core::rand;
use core::task;
use core::pipes::{stream, SharedChan};
#[test]
pub fn test_gl_timer_simple_sleep_test() {
@ -195,8 +202,8 @@ mod test {
#[test]
pub fn test_gl_timer_sleep_stress2() {
let po = oldcomm::Port();
let ch = oldcomm::Chan(&po);
let (po, ch) = stream();
let ch = SharedChan(ch);
let hl_loop = &uv::global_loop::get();
let repeat = 20u;
@ -210,8 +217,10 @@ mod test {
for iter::repeat(repeat) {
let ch = ch.clone();
for spec.each |spec| {
let (times, maxms) = *spec;
let ch = ch.clone();
let hl_loop_clone = hl_loop.clone();
do task::spawn {
use rand::*;
@ -219,13 +228,13 @@ mod test {
for iter::repeat(times) {
sleep(&hl_loop_clone, rng.next() as uint % maxms);
}
oldcomm::send(ch, ());
ch.send(());
}
}
}
for iter::repeat(repeat * spec.len()) {
oldcomm::recv(po)
po.recv()
}
}
@ -246,14 +255,13 @@ mod test {
task::yield();
let expected = rand::rng().gen_str(16u);
let test_po = core::comm::port::<str>();
let test_ch = core::comm::chan(test_po);
let (test_po, test_ch) = stream::<~str>();
do task::spawn() {
delayed_send(hl_loop, 1u, test_ch, expected);
delayed_send(hl_loop, 1u, &test_ch, expected);
};
match recv_timeout(hl_loop, 10u, test_po) {
match recv_timeout(hl_loop, 10u, &test_po) {
Some(val) => {
assert val == expected;
successes += 1;
@ -274,14 +282,13 @@ mod test {
for iter::repeat(times as uint) {
let expected = rand::Rng().gen_str(16u);
let test_po = oldcomm::Port::<~str>();
let test_ch = oldcomm::Chan(&test_po);
let (test_po, test_ch) = stream::<~str>();
let hl_loop_clone = hl_loop.clone();
do task::spawn() {
delayed_send(&hl_loop_clone, 50u, test_ch, expected);
delayed_send(&hl_loop_clone, 50u, &test_ch, expected);
};
match recv_timeout(&hl_loop, 1u, test_po) {
match recv_timeout(&hl_loop, 1u, &test_po) {
None => successes += 1,
_ => failures += 1
};

34
src/libstd/uv_iotask.rs
View file

@ -209,16 +209,17 @@ mod test {
use core::iter;
use core::libc;
use core::oldcomm;
use core::ptr;
use core::task;
use core::pipes::{stream, Chan, SharedChan, Port};
extern fn async_close_cb(handle: *ll::uv_async_t) {
unsafe {
log(debug, fmt!("async_close_cb handle %?", handle));
let exit_ch = (*(ll::get_data_for_uv_handle(handle)
let exit_ch = &(*(ll::get_data_for_uv_handle(handle)
as *AhData)).exit_ch;
oldcomm::send(exit_ch, ());
let exit_ch = exit_ch.clone();
exit_ch.send(());
}
}
extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int) {
@ -230,17 +231,16 @@ mod test {
}
struct AhData {
iotask: IoTask,
exit_ch: oldcomm::Chan<()>
exit_ch: SharedChan<()>
}
fn impl_uv_iotask_async(iotask: &IoTask) {
unsafe {
let async_handle = ll::async_t();
let ah_ptr = ptr::addr_of(&async_handle);
let exit_po = oldcomm::Port::<()>();
let exit_ch = oldcomm::Chan(&exit_po);
let (exit_po, exit_ch) = stream::<()>();
let ah_data = AhData {
iotask: iotask.clone(),
exit_ch: exit_ch
exit_ch: SharedChan(exit_ch)
};
let ah_data_ptr: *AhData = unsafe {
ptr::to_unsafe_ptr(&ah_data)
@ -256,13 +256,13 @@ mod test {
}
};
debug!("waiting for async close");
oldcomm::recv(exit_po);
exit_po.recv();
}
}
// this fn documents the bear minimum neccesary to roll your own
// high_level_loop
unsafe fn spawn_test_loop(exit_ch: oldcomm::Chan<()>) -> IoTask {
unsafe fn spawn_test_loop(exit_ch: ~Chan<()>) -> IoTask {
let (iotask_port, iotask_ch) = stream::<IoTask>();
do task::spawn_sched(task::ManualThreads(1u)) {
debug!("about to run a test loop");
@ -287,9 +287,8 @@ mod test {
#[test]
fn test_uv_iotask_async() {
unsafe {
let exit_po = oldcomm::Port::<()>();
let exit_ch = oldcomm::Chan(&exit_po);
let iotask = &spawn_test_loop(exit_ch);
let (exit_po, exit_ch) = stream::<()>();
let iotask = &spawn_test_loop(~exit_ch);
debug!("spawned iotask");
@ -300,24 +299,25 @@ mod test {
// race-condition type situations.. this ensures that the
// loop lives until, at least, all of the
// impl_uv_hl_async() runs have been called, at least.
let work_exit_po = oldcomm::Port::<()>();
let work_exit_ch = oldcomm::Chan(&work_exit_po);
let (work_exit_po, work_exit_ch) = stream::<()>();
let work_exit_ch = SharedChan(work_exit_ch);
for iter::repeat(7u) {
let iotask_clone = iotask.clone();
let work_exit_ch_clone = work_exit_ch.clone();
do task::spawn_sched(task::ManualThreads(1u)) {
debug!("async");
impl_uv_iotask_async(&iotask_clone);
debug!("done async");
oldcomm::send(work_exit_ch, ());
work_exit_ch_clone.send(());
};
};
for iter::repeat(7u) {
debug!("waiting");
oldcomm::recv(work_exit_po);
work_exit_po.recv();
};
log(debug, ~"sending teardown_loop msg..");
exit(iotask);
oldcomm::recv(exit_po);
exit_po.recv();
log(debug, ~"after recv on exit_po.. exiting..");
}
}

59
src/libstd/uv_ll.rs
View file

@ -39,6 +39,7 @@ use core::ptr::to_unsafe_ptr;
use core::ptr;
use core::str;
use core::vec;
use core::pipes::{stream, Chan, SharedChan, Port};
// libuv struct mappings
pub struct uv_ip4_addr {
@ -1132,7 +1133,6 @@ pub mod test {
use uv_ll::*;
use core::libc;
use core::oldcomm;
use core::ptr;
use core::str;
use core::sys;
@ -1148,7 +1148,7 @@ pub mod test {
struct request_wrapper {
write_req: *uv_write_t,
req_buf: *~[uv_buf_t],
read_chan: *oldcomm::Chan<~str>,
read_chan: SharedChan<~str>,
}
extern fn after_close_cb(handle: *libc::c_void) {
@ -1187,9 +1187,9 @@ pub mod test {
let buf_base = get_base_from_buf(buf);
let buf_len = get_len_from_buf(buf);
let bytes = vec::from_buf(buf_base, buf_len as uint);
let read_chan = *((*client_data).read_chan);
let read_chan = (*client_data).read_chan.clone();
let msg_from_server = str::from_bytes(bytes);
oldcomm::send(read_chan, msg_from_server);
read_chan.send(msg_from_server);
close(stream as *libc::c_void, after_close_cb)
}
else if (nread == -1) {
@ -1257,7 +1257,7 @@ pub mod test {
}
fn impl_uv_tcp_request(ip: &str, port: int, req_str: &str,
client_chan: *oldcomm::Chan<~str>) {
client_chan: SharedChan<~str>) {
unsafe {
let test_loop = loop_new();
let tcp_handle = tcp_t();
@ -1283,9 +1283,11 @@ pub mod test {
log(debug, fmt!("tcp req: tcp stream: %d write_handle: %d",
tcp_handle_ptr as int,
write_handle_ptr as int));
let client_data = { writer_handle: write_handle_ptr,
req_buf: ptr::addr_of(&req_msg),
read_chan: client_chan };
let client_data = request_wrapper {
write_req: write_handle_ptr,
req_buf: ptr::addr_of(&req_msg),
read_chan: client_chan
};
let tcp_init_result = tcp_init(
test_loop as *libc::c_void, tcp_handle_ptr);
@ -1388,8 +1390,8 @@ pub mod test {
log(debug, ~"SERVER: client req contains kill_msg!");
log(debug, ~"SERVER: sending response to client");
read_stop(client_stream_ptr);
let server_chan = *((*client_data).server_chan);
oldcomm::send(server_chan, request_str);
let server_chan = (*client_data).server_chan.clone();
server_chan.send(request_str);
let write_result = write(
write_req,
client_stream_ptr as *libc::c_void,
@ -1484,12 +1486,12 @@ pub mod test {
server: *uv_tcp_t,
server_kill_msg: ~str,
server_resp_buf: *~[uv_buf_t],
server_chan: *oldcomm::Chan<~str>,
server_chan: SharedChan<~str>,
server_write_req: *uv_write_t,
}
struct async_handle_data {
continue_chan: *oldcomm::Chan<bool>,
continue_chan: SharedChan<bool>,
}
extern fn async_close_cb(handle: *libc::c_void) {
@ -1506,9 +1508,9 @@ pub mod test {
// do its thang
let data = get_data_for_uv_handle(
async_handle as *libc::c_void) as *async_handle_data;
let continue_chan = *((*data).continue_chan);
let continue_chan = (*data).continue_chan.clone();
let should_continue = status == 0i32;
oldcomm::send(continue_chan, should_continue);
continue_chan.send(should_continue);
close(async_handle as *libc::c_void, async_close_cb);
}
}
@ -1517,8 +1519,8 @@ pub mod test {
server_port: int,
+kill_server_msg: ~str,
+server_resp_msg: ~str,
server_chan: *oldcomm::Chan<~str>,
continue_chan: *oldcomm::Chan<bool>) {
server_chan: SharedChan<~str>,
continue_chan: SharedChan<bool>) {
unsafe {
let test_loop = loop_new();
let tcp_server = tcp_t();
@ -1626,36 +1628,35 @@ pub mod test {
let port = 8886;
let kill_server_msg = ~"does a dog have buddha nature?";
let server_resp_msg = ~"mu!";
let client_port = oldcomm::Port::<~str>();
let client_chan = oldcomm::Chan::<~str>(&client_port);
let server_port = oldcomm::Port::<~str>();
let server_chan = oldcomm::Chan::<~str>(&server_port);
let (client_port, client_chan) = stream::<~str>();
let client_chan = SharedChan(client_chan);
let (server_port, server_chan) = stream::<~str>();
let server_chan = SharedChan(server_chan);
let continue_port = oldcomm::Port::<bool>();
let continue_chan = oldcomm::Chan::<bool>(&continue_port);
let continue_chan_ptr = ptr::addr_of(&continue_chan);
let (continue_port, continue_chan) = stream::<bool>();
let continue_chan = SharedChan(continue_chan);
do task::spawn_sched(task::ManualThreads(1)) {
impl_uv_tcp_server(bind_ip, port,
kill_server_msg,
server_resp_msg,
ptr::addr_of(&server_chan),
continue_chan_ptr);
server_chan.clone(),
continue_chan.clone());
};
// block until the server up is.. possibly a race?
log(debug, ~"before receiving on server continue_port");
oldcomm::recv(continue_port);
continue_port.recv();
log(debug, ~"received on continue port, set up tcp client");
do task::spawn_sched(task::ManualThreads(1u)) {
impl_uv_tcp_request(request_ip, port,
kill_server_msg,
ptr::addr_of(&client_chan));
client_chan.clone());
};
let msg_from_client = oldcomm::recv(server_port);
let msg_from_server = oldcomm::recv(client_port);
let msg_from_client = server_port.recv();
let msg_from_server = client_port.recv();
assert str::contains(msg_from_client, kill_server_msg);
assert str::contains(msg_from_server, server_resp_msg);