Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
81b8e20f
R
Rust
项目概览
int
/
Rust
大约 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
81b8e20f
编写于
5月 24, 2012
作者:
B
Brian Anderson
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
std: Rename uv::hl to uv::iotask. Additional cleanup
上级
59262dfc
变更
6
隐藏空白更改
内联
并排
Showing
6 changed file
with
156 addition
and
158 deletion
+156
-158
src/libstd/net_tcp.rs
src/libstd/net_tcp.rs
+39
-37
src/libstd/std.rc
src/libstd/std.rc
+2
-2
src/libstd/timer.rs
src/libstd/timer.rs
+10
-8
src/libstd/uv.rs
src/libstd/uv.rs
+2
-2
src/libstd/uv_global_loop.rs
src/libstd/uv_global_loop.rs
+11
-10
src/libstd/uv_iotask.rs
src/libstd/uv_iotask.rs
+92
-99
未找到文件。
src/libstd/net_tcp.rs
浏览文件 @
81b8e20f
...
...
@@ -4,6 +4,8 @@
// FIXME: Fewer import *'s
import
ip
=
net_ip
;
import
uv
::
iotask
;
import
uv
::
iotask
::
iotask
;
import
comm
::
*
;
import
result
::
*
;
import
str
::
*
;
...
...
@@ -44,7 +46,7 @@
};
let
close_data_ptr
=
ptr
::
addr_of
(
close_data
);
let
stream_handle_ptr
=
(
*
socket_data
)
.stream_handle_ptr
;
uv
::
hl
::
interact
((
*
socket_data
)
.hl_loop
)
{|
loop_ptr
|
iotask
::
interact
((
*
socket_data
)
.iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"interact dtor for tcp_socket stream %? loop %?"
,
stream_handle_ptr
,
loop_ptr
));
uv
::
ll
::
set_data_for_uv_handle
(
stream_handle_ptr
,
...
...
@@ -62,8 +64,8 @@
let
conn_data_ptr
=
ptr
::
addr_of
(
*
conn_data
);
let
server_stream_ptr
=
ptr
::
addr_of
((
*
conn_data_ptr
)
.server_stream
);
let
stream_closed_po
=
(
*
conn_data
)
.stream_closed_po
;
let
hl_loop
=
(
*
conn_data_ptr
)
.hl_loop
;
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
let
iotask
=
(
*
conn_data_ptr
)
.iotask
;
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"dtor for tcp_conn_port loop: %?"
,
loop_ptr
));
uv
::
ll
::
close
(
server_stream_ptr
,
tcp_nl_close_cb
);
...
...
@@ -86,7 +88,7 @@
* `ip` - The IP address (versions 4 or 6) of the remote host
* `port` - the unsigned integer of the desired remote host port
* `
hl_loop` - a `uv::hl::high_level_loop
` that the tcp request will run on
* `
iotask` - a `uv::iotask
` that the tcp request will run on
# Returns
...
...
@@ -95,7 +97,7 @@
of failure, a `tcp_err_data` will be returned
"
]
fn
connect
(
input_ip
:
ip
::
ip_addr
,
port
:
uint
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
iotask
:
iotask
)
->
result
::
result
<
tcp_socket
,
tcp_err_data
>
unsafe
{
let
result_po
=
comm
::
port
::
<
conn_attempt
>
();
let
closed_signal_po
=
comm
::
port
::
<
()
>
();
...
...
@@ -113,7 +115,7 @@ fn connect(input_ip: ip::ip_addr, port: uint,
stream_handle_ptr
:
stream_handle_ptr
,
connect_req
:
uv
::
ll
::
connect_t
(),
write_req
:
uv
::
ll
::
write_t
(),
hl_loop
:
hl_loop
iotask
:
iotask
};
let
socket_data_ptr
=
ptr
::
addr_of
(
*
socket_data
);
log
(
debug
,
#
fmt
(
"tcp_connect result_ch %?"
,
conn_data
.result_ch
));
...
...
@@ -121,7 +123,7 @@ fn connect(input_ip: ip::ip_addr, port: uint,
// we can send into the interact cb to be handled in libuv..
log
(
debug
,
#
fmt
(
"stream_handle_ptr outside interact %?"
,
stream_handle_ptr
));
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
log
(
debug
,
"in interact cb for tcp client connect.."
);
log
(
debug
,
#
fmt
(
"stream_handle_ptr in interact %?"
,
stream_handle_ptr
));
...
...
@@ -354,7 +356,7 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
failure to create the tcp listener occurs
"
]
fn
new_listener
(
host_ip
:
ip
::
ip_addr
,
port
:
uint
,
backlog
:
uint
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
iotask
:
iotask
)
->
result
::
result
<
tcp_conn_port
,
tcp_err_data
>
unsafe
{
let
stream_closed_po
=
comm
::
port
::
<
()
>
();
let
stream_closed_ch
=
comm
::
chan
(
stream_closed_po
);
...
...
@@ -367,7 +369,7 @@ fn new_listener(host_ip: ip::ip_addr, port: uint, backlog: uint,
server_stream
:
uv
::
ll
::
tcp_t
(),
stream_closed_po
:
stream_closed_po
,
stream_closed_ch
:
stream_closed_ch
,
hl_loop
:
hl_loop
,
iotask
:
iotask
,
new_conn_po
:
new_conn_po
,
new_conn_ch
:
new_conn_ch
};
...
...
@@ -377,7 +379,7 @@ fn new_listener(host_ip: ip::ip_addr, port: uint, backlog: uint,
let
setup_po
=
comm
::
port
::
<
option
<
tcp_err_data
>>
();
let
setup_ch
=
comm
::
chan
(
setup_po
);
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
let
tcp_addr
=
ipv4_ip_addr_to_sockaddr_in
(
host_ip
,
port
);
alt
uv
::
ll
::
tcp_init
(
loop_ptr
,
server_stream_ptr
)
{
...
...
@@ -445,11 +447,11 @@ fn new_listener(host_ip: ip::ip_addr, port: uint, backlog: uint,
fn
conn_recv
(
server_port
:
tcp_conn_port
)
->
result
::
result
<
tcp_socket
,
tcp_err_data
>
{
let
new_conn_po
=
(
**
server_port
)
.new_conn_po
;
let
hl_loop
=
(
**
server_port
)
.hl_loop
;
let
iotask
=
(
**
server_port
)
.iotask
;
let
new_conn_result
=
comm
::
recv
(
new_conn_po
);
alt
new_conn_result
{
ok
(
client_stream_ptr
)
{
conn_port_new_tcp_socket
(
client_stream_ptr
,
hl_loop
)
conn_port_new_tcp_socket
(
client_stream_ptr
,
iotask
)
}
err
(
err_data
)
{
result
::
err
(
err_data
)
...
...
@@ -476,12 +478,12 @@ fn conn_recv(server_port: tcp_conn_port)
fn
conn_recv_spawn
(
server_port
:
tcp_conn_port
,
cb
:
fn
~
(
result
::
result
<
tcp_socket
,
tcp_err_data
>
))
{
let
new_conn_po
=
(
**
server_port
)
.new_conn_po
;
let
hl_loop
=
(
**
server_port
)
.hl_loop
;
let
iotask
=
(
**
server_port
)
.iotask
;
let
new_conn_result
=
comm
::
recv
(
new_conn_po
);
task
::
spawn
{||
let
sock_create_result
=
alt
new_conn_result
{
ok
(
client_stream_ptr
)
{
conn_port_new_tcp_socket
(
client_stream_ptr
,
hl_loop
)
conn_port_new_tcp_socket
(
client_stream_ptr
,
iotask
)
}
err
(
err_data
)
{
result
::
err
(
err_data
)
...
...
@@ -582,7 +584,7 @@ fn accept(new_conn: tcp_new_connection)
let
server_data_ptr
=
uv
::
ll
::
get_data_for_uv_handle
(
server_handle_ptr
)
as
*
tcp_listen_fc_data
;
let
reader_po
=
comm
::
port
::
<
result
::
result
<
[
u8
],
tcp_err_data
>>
();
let
hl_loop
=
(
*
server_data_ptr
)
.hl_loop
;
let
iotask
=
(
*
server_data_ptr
)
.iotask
;
let
stream_handle_ptr
=
malloc_uv_tcp_t
();
*
(
stream_handle_ptr
as
*
mut
uv
::
ll
::
uv_tcp_t
)
=
uv
::
ll
::
tcp_t
();
let
client_socket_data
=
@
{
...
...
@@ -591,7 +593,7 @@ fn accept(new_conn: tcp_new_connection)
stream_handle_ptr
:
stream_handle_ptr
,
connect_req
:
uv
::
ll
::
connect_t
(),
write_req
:
uv
::
ll
::
write_t
(),
hl_loop
:
hl_loop
iotask
:
iotask
};
let
client_socket_data_ptr
=
ptr
::
addr_of
(
*
client_socket_data
);
let
client_stream_handle_ptr
=
...
...
@@ -677,7 +679,7 @@ fn accept(new_conn: tcp_new_connection)
of listen exiting because of an error
"
]
fn
listen_for_conn
(
host_ip
:
ip
::
ip_addr
,
port
:
uint
,
backlog
:
uint
,
hl_loop
:
uv
::
hl
::
high_level_loop
,
iotask
:
iotask
,
on_establish_cb
:
fn
~
(
comm
::
chan
<
option
<
tcp_err_data
>>
),
new_connect_cb
:
fn
~
(
tcp_new_connection
,
comm
::
chan
<
option
<
tcp_err_data
>>
))
...
...
@@ -692,14 +694,14 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
stream_closed_ch
:
comm
::
chan
(
stream_closed_po
),
kill_ch
:
kill_ch
,
new_connect_cb
:
new_connect_cb
,
hl_loop
:
hl_loop
,
iotask
:
iotask
,
mut
active
:
true
};
let
server_data_ptr
=
ptr
::
addr_of
(
server_data
);
let
setup_po
=
comm
::
port
::
<
option
<
tcp_err_data
>>
();
let
setup_ch
=
comm
::
chan
(
setup_po
);
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
let
tcp_addr
=
ipv4_ip_addr_to_sockaddr_in
(
host_ip
,
port
);
alt
uv
::
ll
::
tcp_init
(
loop_ptr
,
server_stream_ptr
)
{
...
...
@@ -745,7 +747,7 @@ fn listen_for_conn(host_ip: ip::ip_addr, port: uint, backlog: uint,
none
{
on_establish_cb
(
kill_ch
);
let
kill_result
=
comm
::
recv
(
kill_po
);
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"tcp::listen post-kill recv hl interact %?"
,
loop_ptr
));
(
*
server_data_ptr
)
.active
=
false
;
...
...
@@ -811,7 +813,7 @@ fn write_future(raw_write_data: [u8])
fn
read_common_impl
(
socket_data
:
*
tcp_socket_data
,
timeout_msecs
:
uint
)
->
result
::
result
<
[
u8
],
tcp_err_data
>
unsafe
{
log
(
debug
,
"starting tcp::read"
);
let
hl_loop
=
(
*
socket_data
)
.hl_loop
;
let
iotask
=
(
*
socket_data
)
.iotask
;
let
rs_result
=
read_start_common_impl
(
socket_data
);
if
result
::
is_failure
(
rs_result
)
{
let
err_data
=
result
::
get_err
(
rs_result
);
...
...
@@ -821,7 +823,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
log
(
debug
,
"tcp::read before recv_timeout"
);
let
read_result
=
if
timeout_msecs
>
0u
{
timer
::
recv_timeout
(
hl_loop
,
timeout_msecs
,
result
::
get
(
rs_result
))
iotask
,
timeout_msecs
,
result
::
get
(
rs_result
))
}
else
{
some
(
comm
::
recv
(
result
::
get
(
rs_result
)))
};
...
...
@@ -851,7 +853,7 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
let
stream_handle_ptr
=
(
*
socket_data
)
.stream_handle_ptr
;
let
stop_po
=
comm
::
port
::
<
option
<
tcp_err_data
>>
();
let
stop_ch
=
comm
::
chan
(
stop_po
);
uv
::
hl
::
interact
((
*
socket_data
)
.hl_loop
)
{|
loop_ptr
|
iotask
::
interact
((
*
socket_data
)
.iotask
)
{|
loop_ptr
|
log
(
debug
,
"in interact cb for tcp::read_stop"
);
alt
uv
::
ll
::
read_stop
(
stream_handle_ptr
as
*
uv
::
ll
::
uv_stream_t
)
{
0i32
{
...
...
@@ -883,7 +885,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
let
start_po
=
comm
::
port
::
<
option
<
uv
::
ll
::
uv_err_data
>>
();
let
start_ch
=
comm
::
chan
(
start_po
);
log
(
debug
,
"in tcp::read_start before interact loop"
);
uv
::
hl
::
interact
((
*
socket_data
)
.hl_loop
)
{|
loop_ptr
|
iotask
::
interact
((
*
socket_data
)
.iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"in tcp::read_start interact cb %?"
,
loop_ptr
));
alt
uv
::
ll
::
read_start
(
stream_handle_ptr
as
*
uv
::
ll
::
uv_stream_t
,
on_alloc_cb
,
...
...
@@ -925,7 +927,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
result_ch
:
comm
::
chan
(
result_po
)
};
let
write_data_ptr
=
ptr
::
addr_of
(
write_data
);
uv
::
hl
::
interact
((
*
socket_data_ptr
)
.hl_loop
)
{|
loop_ptr
|
iotask
::
interact
((
*
socket_data_ptr
)
.iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"in interact cb for tcp::write %?"
,
loop_ptr
));
alt
uv
::
ll
::
write
(
write_req_ptr
,
stream_handle_ptr
,
...
...
@@ -956,7 +958,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
// various recv_* can use a tcp_conn_port can re-use this..
fn
conn_port_new_tcp_socket
(
stream_handle_ptr
:
*
uv
::
ll
::
uv_tcp_t
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
iotask
:
iotask
)
->
result
::
result
<
tcp_socket
,
tcp_err_data
>
unsafe
{
// tcp_nl_on_connection_cb
let
reader_po
=
comm
::
port
::
<
result
::
result
<
[
u8
],
tcp_err_data
>>
();
...
...
@@ -966,11 +968,11 @@ fn conn_port_new_tcp_socket(
stream_handle_ptr
:
stream_handle_ptr
,
connect_req
:
uv
::
ll
::
connect_t
(),
write_req
:
uv
::
ll
::
write_t
(),
hl_loop
:
hl_loop
iotask
:
iotask
};
let
client_socket_data_ptr
=
ptr
::
addr_of
(
*
client_socket_data
);
comm
::
listen
{|
cont_ch
|
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
log
(
debug
,
#
fmt
(
"in interact cb 4 conn_port_new_tcp.. loop %?"
,
loop_ptr
));
uv
::
ll
::
set_data_for_uv_handle
(
stream_handle_ptr
,
...
...
@@ -990,7 +992,7 @@ enum tcp_new_connection {
server_stream
:
uv
::
ll
::
uv_tcp_t
,
stream_closed_po
:
comm
::
port
<
()
>
,
stream_closed_ch
:
comm
::
chan
<
()
>
,
hl_loop
:
uv
::
hl
::
high_level_loop
,
iotask
:
iotask
,
new_conn_po
:
comm
::
port
<
result
::
result
<*
uv
::
ll
::
uv_tcp_t
,
tcp_err_data
>>
,
new_conn_ch
:
comm
::
chan
<
result
::
result
<*
uv
::
ll
::
uv_tcp_t
,
...
...
@@ -1003,7 +1005,7 @@ enum tcp_new_connection {
kill_ch
:
comm
::
chan
<
option
<
tcp_err_data
>>
,
new_connect_cb
:
fn
~
(
tcp_new_connection
,
comm
::
chan
<
option
<
tcp_err_data
>>
),
hl_loop
:
uv
::
hl
::
high_level_loop
,
iotask
:
iotask
,
mut
active
:
bool
};
...
...
@@ -1264,7 +1266,7 @@ enum conn_attempt {
stream_handle_ptr
:
*
uv
::
ll
::
uv_tcp_t
,
connect_req
:
uv
::
ll
::
uv_connect_t
,
write_req
:
uv
::
ll
::
uv_write_t
,
hl_loop
:
uv
::
hl
::
high_level_loop
iotask
:
iotask
};
// convert rust ip_addr to libuv's native representation
...
...
@@ -1405,13 +1407,13 @@ fn impl_gl_tcp_ipv4_server_listener_and_client() {
fn
run_tcp_test_server
(
server_ip
:
str
,
server_port
:
uint
,
resp
:
str
,
server_ch
:
comm
::
chan
<
str
>
,
cont_ch
:
comm
::
chan
<
()
>
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
->
str
{
iotask
:
iotask
)
->
str
{
task
::
spawn_sched
(
task
::
manual_threads
(
1u
))
{||
let
server_ip_addr
=
ip
::
v4
::
parse_addr
(
server_ip
);
let
listen_result
=
listen_for_conn
(
server_ip_addr
,
server_port
,
128u
,
hl_loop
,
iotask
,
// on_establish_cb -- called when listener is set up
{|
kill_ch
|
log
(
debug
,
#
fmt
(
"establish_cb %?"
,
...
...
@@ -1484,12 +1486,12 @@ fn run_tcp_test_server_listener(server_ip: str,
server_port
:
uint
,
resp
:
str
,
server_ch
:
comm
::
chan
<
str
>
,
cont_ch
:
comm
::
chan
<
()
>
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
->
str
{
iotask
:
iotask
)
->
str
{
task
::
spawn_sched
(
task
::
manual_threads
(
1u
))
{||
let
server_ip_addr
=
ip
::
v4
::
parse_addr
(
server_ip
);
let
new_listener_result
=
new_listener
(
server_ip_addr
,
server_port
,
128u
,
hl_loop
);
new_listener
(
server_ip_addr
,
server_port
,
128u
,
iotask
);
if
result
::
is_failure
(
new_listener_result
)
{
let
err_data
=
result
::
get_err
(
new_listener_result
);
log
(
debug
,
#
fmt
(
"SERVER: exited abnormally name %s msg %s"
,
...
...
@@ -1533,12 +1535,12 @@ fn run_tcp_test_server_listener(server_ip: str,
fn
run_tcp_test_client
(
server_ip
:
str
,
server_port
:
uint
,
resp
:
str
,
client_ch
:
comm
::
chan
<
str
>
,
hl_loop
:
uv
::
hl
::
high_level_loop
)
->
str
{
iotask
:
iotask
)
->
str
{
let
server_ip_addr
=
ip
::
v4
::
parse_addr
(
server_ip
);
log
(
debug
,
"CLIENT: starting.."
);
let
connect_result
=
connect
(
server_ip_addr
,
server_port
,
hl_loop
);
let
connect_result
=
connect
(
server_ip_addr
,
server_port
,
iotask
);
if
result
::
is_failure
(
connect_result
)
{
log
(
debug
,
"CLIENT: failed to connect"
);
let
err_data
=
result
::
get_err
(
connect_result
);
...
...
src/libstd/std.rc
浏览文件 @
81b8e20f
...
...
@@ -14,7 +14,7 @@ use core(vers = "0.2");
import core::*;
export net, net_tcp;
export uv, uv_ll, uv_
hl
, uv_global_loop;
export uv, uv_ll, uv_
iotask
, uv_global_loop;
export c_vec, util, timer;
export bitv, deque, fun_treemap, list, map, smallintmap, sort, treemap;
export rope, arena, arc;
...
...
@@ -30,7 +30,7 @@ mod net_tcp;
// libuv modules
mod uv;
mod uv_ll;
mod uv_
hl
;
mod uv_
iotask
;
mod uv_global_loop;
...
...
src/libstd/timer.rs
浏览文件 @
81b8e20f
...
...
@@ -3,6 +3,8 @@
"
]
;
import
uv
=
uv
;
import
uv
::
iotask
;
import
iotask
::
iotask
;
export
delayed_send
,
sleep
,
recv_timeout
;
#[doc
=
"
...
...
@@ -21,7 +23,7 @@
* ch - a channel of type T to send a `val` on
* val - a value of type T to send over the provided `ch`
"
]
fn
delayed_send
<
T
:
copy
send
>
(
hl_loop
:
uv
::
hl
::
high_level_loop
,
fn
delayed_send
<
T
:
copy
send
>
(
iotask
:
iotask
,
msecs
:
uint
,
ch
:
comm
::
chan
<
T
>
,
val
:
T
)
{
// FIME: Looks like we don't need to spawn here
task
::
spawn
()
{||
...
...
@@ -31,7 +33,7 @@ fn delayed_send<T: copy send>(hl_loop: uv::hl::high_level_loop,
let
timer_done_ch_ptr
=
ptr
::
addr_of
(
timer_done_ch
);
let
timer
=
uv
::
ll
::
timer_t
();
let
timer_ptr
=
ptr
::
addr_of
(
timer
);
uv
::
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
let
init_result
=
uv
::
ll
::
timer_init
(
loop_ptr
,
timer_ptr
);
if
(
init_result
==
0i32
)
{
let
start_result
=
uv
::
ll
::
timer_start
(
...
...
@@ -69,13 +71,13 @@ fn delayed_send<T: copy send>(hl_loop: uv::hl::high_level_loop,
# Arguments
* `
hl_loop` - a `uv::hl::high_level_loop
` that the tcp request will run on
* `
iotask` - a `uv::iotask
` that the tcp request will run on
* msecs - an amount of time, in milliseconds, for the current task to block
"
]
fn
sleep
(
hl_loop
:
uv
::
hl
::
high_level_loop
,
msecs
:
uint
)
{
fn
sleep
(
iotask
:
iotask
,
msecs
:
uint
)
{
let
exit_po
=
comm
::
port
::
<
()
>
();
let
exit_ch
=
comm
::
chan
(
exit_po
);
delayed_send
(
hl_loop
,
msecs
,
exit_ch
,
());
delayed_send
(
iotask
,
msecs
,
exit_ch
,
());
comm
::
recv
(
exit_po
);
}
...
...
@@ -88,7 +90,7 @@ fn sleep(hl_loop: uv::hl::high_level_loop, msecs: uint) {
# Arguments
* `
hl_loop` - a `uv::hl::high_level_loop
` that the tcp request will run on
* `
iotask' - `uv::iotask
` that the tcp request will run on
* msecs - an mount of time, in milliseconds, to wait to receive
* wait_port - a `comm::port<T>` to receive on
...
...
@@ -98,12 +100,12 @@ fn sleep(hl_loop: uv::hl::high_level_loop, msecs: uint) {
the provided port in the allotted timeout period, then the result will be a
`some(T)`. If not, then `none` will be returned.
"
]
fn
recv_timeout
<
T
:
copy
send
>
(
hl_loop
:
uv
::
hl
::
high_level_loop
,
fn
recv_timeout
<
T
:
copy
send
>
(
iotask
:
iotask
,
msecs
:
uint
,
wait_po
:
comm
::
port
<
T
>
)
->
option
<
T
>
{
let
timeout_po
=
comm
::
port
::
<
()
>
();
let
timeout_ch
=
comm
::
chan
(
timeout_po
);
delayed_send
(
hl_loop
,
msecs
,
timeout_ch
,
());
delayed_send
(
iotask
,
msecs
,
timeout_ch
,
());
// FIXME: This could be written clearer
either
::
either
(
{|
left_val
|
...
...
src/libstd/uv.rs
浏览文件 @
81b8e20f
...
...
@@ -26,8 +26,8 @@
import
ll
=
uv_ll
;
export
ll
;
import
hl
=
uv_hl
;
export
hl
;
import
iotask
=
uv_iotask
;
export
iotask
;
import
global_loop
=
uv_global_loop
;
export
global_loop
;
src/libstd/uv_global_loop.rs
浏览文件 @
81b8e20f
...
...
@@ -5,8 +5,9 @@
export
get
,
get_monitor_task_gl
;
import
ll
=
uv_ll
;
import
hl
=
uv_hl
;
import
iotask
=
uv_iotask
;
import
get_gl
=
get
;
import
iotask
::{
iotask
,
spawn_iotask
};
import
priv
::{
chan_from_global_ptr
,
weaken_task
};
import
comm
::{
port
,
chan
,
methods
,
select2
,
listen
};
import
either
::{
left
,
right
};
...
...
@@ -27,12 +28,12 @@
* A `hl::high_level_loop` that encapsulates communication with the global
loop.
"
]
fn
get
()
->
hl
::
high_level_loop
{
fn
get
()
->
iotask
{
ret
get_monitor_task_gl
();
}
#[doc(hidden)]
fn
get_monitor_task_gl
()
->
hl
::
high_level_loop
unsafe
{
fn
get_monitor_task_gl
()
->
iotask
unsafe
{
let
monitor_loop_chan_ptr
=
rustrt
::
rust_uv_get_kernel_global_chan_ptr
();
...
...
@@ -53,7 +54,7 @@ fn get_monitor_task_gl() -> hl::high_level_loop unsafe {
};
#
debug
(
"before priv::chan_from_global_ptr"
);
type
monchan
=
chan
<
hl
::
high_level_loop
>
;
type
monchan
=
chan
<
iotask
>
;
let
monitor_ch
=
chan_from_global_ptr
::
<
monchan
>
(
monitor_loop_chan_ptr
,
builder_fn
)
{|
msg_po
|
...
...
@@ -70,7 +71,7 @@ fn get_monitor_task_gl() -> hl::high_level_loop unsafe {
// all normal tasks have ended, tell the
// libuv loop to tear_down, then exit
#
debug
(
"weak_exit_po recv'd msg: %?"
,
weak_exit
);
hl
::
exit
(
hl_loop
);
iotask
::
exit
(
hl_loop
);
break
;
}
right
(
fetch_ch
)
{
...
...
@@ -92,7 +93,7 @@ fn get_monitor_task_gl() -> hl::high_level_loop unsafe {
}
}
fn
spawn_loop
()
->
hl
::
high_level_loop
unsafe
{
fn
spawn_loop
()
->
iotask
unsafe
{
let
builder
=
task
::
builder
();
task
::
add_wrapper
(
builder
)
{|
task_body
|
fn
~
(
move
task_body
)
{
...
...
@@ -110,7 +111,7 @@ fn spawn_loop() -> hl::high_level_loop unsafe {
}
}
}
hl
::
spawn_high_level_loop
(
builder
)
spawn_iotask
(
builder
)
}
#[cfg(test)]
...
...
@@ -128,7 +129,7 @@ mod test {
log
(
debug
,
"in simple timer cb"
);
ll
::
timer_stop
(
timer_ptr
);
let
hl_loop
=
get_gl
();
hl
::
interact
(
hl_loop
)
{|
_
loop_ptr
|
iotask
::
interact
(
hl_loop
)
{|
_
loop_ptr
|
log
(
debug
,
"closing timer"
);
ll
::
close
(
timer_ptr
,
simple_timer_close_cb
);
log
(
debug
,
"about to deref exit_ch_ptr"
);
...
...
@@ -137,7 +138,7 @@ mod test {
log
(
debug
,
"exiting simple timer cb"
);
}
fn
impl_uv_hl_simple_timer
(
hl_loop
:
hl
::
high_level_loop
)
unsafe
{
fn
impl_uv_hl_simple_timer
(
iotask
:
iotask
)
unsafe
{
let
exit_po
=
comm
::
port
::
<
bool
>
();
let
exit_ch
=
comm
::
chan
(
exit_po
);
let
exit_ch_ptr
=
ptr
::
addr_of
(
exit_ch
);
...
...
@@ -145,7 +146,7 @@ fn impl_uv_hl_simple_timer(hl_loop: hl::high_level_loop) unsafe {
exit_ch_ptr
));
let
timer_handle
=
ll
::
timer_t
();
let
timer_ptr
=
ptr
::
addr_of
(
timer_handle
);
hl
::
interact
(
hl_loop
)
{|
loop_ptr
|
iotask
::
interact
(
iotask
)
{|
loop_ptr
|
log
(
debug
,
"user code inside interact loop!!!"
);
let
init_status
=
ll
::
timer_init
(
loop_ptr
,
timer_ptr
);
if
(
init_status
==
0i32
)
{
...
...
src/libstd/uv_
hl
.rs
→
src/libstd/uv_
iotask
.rs
浏览文件 @
81b8e20f
#[doc
=
"
High-level bindings to work with the libuv library.
This module is geared towards library developers who want to
provide a high-level, abstracted interface to some set of
libuv functionality.
A task-based interface to the uv loop
The I/O task runs in its own single-threaded scheduler. By using the
`interact` function you can execute code in a uv callback.
"
]
;
export
high_level_loop
;
export
spawn_
high_level_loop
;
export
iotask
::{}
;
export
spawn_
iotask
;
export
interact
;
export
exit
;
...
...
@@ -19,18 +20,19 @@
#[doc
=
"
Used to abstract-away direct interaction with a libuv loop.
"
]
enum
high_level_loop
=
{
async_handle
:
*
ll
::
uv_async_t
,
op_chan
:
chan
<
high_level_msg
>
};
enum
iotask
{
iotask_
({
async_handle
:
*
ll
::
uv_async_t
,
op_chan
:
chan
<
iotask_msg
>
})
}
fn
spawn_high_level_loop
(
-
builder
:
task
::
builder
)
->
high_level_loop
unsafe
{
fn
spawn_iotask
(
-
builder
:
task
::
builder
)
->
iotask
{
import
task
::{
set_opts
,
get_opts
,
single_threaded
,
run
};
let
hll_po
=
port
::
<
high_level_loop
>
();
let
hll_ch
=
hll
_po
.chan
();
let
iotask_po
=
port
::
<
iotask
>
();
let
iotask_ch
=
iotask
_po
.chan
();
set_opts
(
builder
,
{
sched
:
some
({
...
...
@@ -42,45 +44,75 @@ fn spawn_high_level_loop(-builder: task::builder
run
(
builder
)
{||
#
debug
(
"entering libuv task"
);
run_
high_level_loop
(
hll
_ch
);
run_
loop
(
iotask
_ch
);
#
debug
(
"libuv task exiting"
);
};
hll
_po
.recv
()
iotask
_po
.recv
()
}
#[doc=
"
Represents the range of interactions with a `high_level_loop`
#[doc
=
"
Provide a callback to be processed by `iotask`
The primary way to do operations again a running `iotask` that
doesn't involve creating a uv handle via `safe_handle`
# Warning
This function is the only safe way to interact with _any_ `iotask`.
Using functions in the `uv::ll` module outside of the `cb` passed into
this function is _very dangerous_.
# Arguments
* iotask - a uv I/O task that you want to do operations against
* cb - a function callback to be processed on the running loop's
thread. The only parameter passed in is an opaque pointer representing the
running `uv_loop_t*`. In the context of this callback, it is safe to use
this pointer to do various uv_* API calls contained within the `uv::ll`
module. It is not safe to send the `loop_ptr` param to this callback out
via ports/chans.
"
]
enum
high_level_msg
{
interaction
(
fn
~
(
*
libc
::
c_void
)),
#[doc=
"
For use in libraries that roll their own `high_level_loop` (like
`std::uv::global_loop`)
unsafe
fn
interact
(
iotask
:
iotask
,
-
cb
:
fn
~
(
*
c_void
))
{
send_msg
(
iotask
,
interaction
(
cb
));
}
#[doc=
"
Shut down the I/O task
Is used to signal to the loop that it should close the internally-held
async handle and do a sanity check to make sure that all other handles are
closed, causing a failure otherwise. This should not be sent/used from
'normal' user code.
"
]
closed, causing a failure otherwise.
"
]
fn
exit
(
iotask
:
iotask
)
unsafe
{
send_msg
(
iotask
,
teardown_loop
);
}
// INTERNAL API
enum
iotask_msg
{
interaction
(
fn
~
(
*
libc
::
c_void
)),
teardown_loop
}
#[doc
=
"
Useful for anyone who wants to roll their own `high_level_loop`.
Run the loop and begin handling messages
"
]
unsafe
fn
run_high_level_loop
(
hll_ch
:
chan
<
high_level_loop
>
)
{
let
msg_po
=
port
::
<
high_level
_msg
>
();
fn
run_loop
(
iotask_ch
:
chan
<
iotask
>
)
unsafe
{
let
msg_po
=
port
::
<
iotask
_msg
>
();
let
loop_ptr
=
ll
::
loop_new
();
// set up the special async handle we'll use to allow multi-task
// communication with this loop
let
async
=
ll
::
async_t
();
let
async_handle
=
addr_of
(
async
);
// associate the async handle with the loop
ll
::
async_init
(
loop_ptr
,
async_handle
,
high_level_
wake_up_cb
);
ll
::
async_init
(
loop_ptr
,
async_handle
,
wake_up_cb
);
// initialize our loop data and store it in the loop
let
data
:
hl
_loop_data
=
{
let
data
:
iotask
_loop_data
=
{
async_handle
:
async_handle
,
mut
active
:
true
,
msg_po_ptr
:
addr_of
(
msg_po
)
...
...
@@ -89,63 +121,30 @@ unsafe fn run_high_level_loop(hll_ch: chan<high_level_loop>) {
// Send out a handle through which folks can talk to us
// while we dwell in the I/O loop
let
hll
=
high_level_loop
({
let
iotask
=
iotask_
({
async_handle
:
async_handle
,
op_chan
:
msg_po
.chan
()
});
hll_ch
.send
(
hll
);
iotask_ch
.send
(
iotask
);
log
(
debug
,
"about to run
high level
loop"
);
log
(
debug
,
"about to run
uv
loop"
);
// enter the loop... this blocks until the loop is done..
ll
::
run
(
loop_ptr
);
log
(
debug
,
"
high-level
loop ended"
);
log
(
debug
,
"
uv
loop ended"
);
ll
::
loop_delete
(
loop_ptr
);
}
#[doc
=
"
Provide a callback to be processed by `a_loop`
The primary way to do operations again a running `high_level_loop` that
doesn't involve creating a uv handle via `safe_handle`
# Warning
This function is the only safe way to interact with _any_ `high_level_loop`.
Using functions in the `uv::ll` module outside of the `cb` passed into
this function is _very dangerous_.
# Arguments
* hl_loop - a `uv::hl::high_level_loop` that you want to do operations against
* cb - a function callback to be processed on the running loop's
thread. The only parameter passed in is an opaque pointer representing the
running `uv_loop_t*`. In the context of this callback, it is safe to use
this pointer to do various uv_* API calls contained within the `uv::ll`
module. It is not safe to send the `loop_ptr` param to this callback out
via ports/chans.
"
]
unsafe
fn
interact
(
hl_loop
:
high_level_loop
,
-
cb
:
fn
~
(
*
c_void
))
{
send_high_level_msg
(
hl_loop
,
interaction
(
cb
));
}
fn
exit
(
hl_loop
:
high_level_loop
)
unsafe
{
send_high_level_msg
(
hl_loop
,
teardown_loop
);
}
// INTERNAL API
// data that lives for the lifetime of the high-evel oo
type
hl
_loop_data
=
{
type
iotask
_loop_data
=
{
async_handle
:
*
ll
::
uv_async_t
,
mut
active
:
bool
,
msg_po_ptr
:
*
port
<
high_level
_msg
>
msg_po_ptr
:
*
port
<
iotask
_msg
>
};
unsafe
fn
send_high_level_msg
(
hl_loop
:
high_level_loop
,
-
msg
:
high_level_msg
)
{
comm
::
send
(
hl_loop
.op_chan
,
msg
);
ll
::
async_send
(
hl_loop
.async_handle
);
fn
send_msg
(
iotask
:
iotask
,
-
msg
:
iotask_msg
)
unsafe
{
iotask
.op_chan
.send
(
msg
);
ll
::
async_send
(
iotask
.async_handle
);
}
// this will be invoked by a call to uv::hl::interact() with
...
...
@@ -153,12 +152,12 @@ unsafe fn send_high_level_msg(hl_loop: high_level_loop,
// simply check if the loop is active and, if so, invoke the
// user-supplied on_wake callback that is stored in the loop's
// data member
crust
fn
high_level_
wake_up_cb
(
async_handle
:
*
ll
::
uv_async_t
,
status
:
int
)
unsafe
{
log
(
debug
,
#
fmt
(
"
high_level_
wake_up_cb crust.. handle: %? status: %?"
,
crust
fn
wake_up_cb
(
async_handle
:
*
ll
::
uv_async_t
,
status
:
int
)
unsafe
{
log
(
debug
,
#
fmt
(
"wake_up_cb crust.. handle: %? status: %?"
,
async_handle
,
status
));
let
loop_ptr
=
ll
::
get_loop_for_uv_handle
(
async_handle
);
let
data
=
ll
::
get_data_for_uv_handle
(
async_handle
)
as
*
hl
_loop_data
;
let
data
=
ll
::
get_data_for_uv_handle
(
async_handle
)
as
*
iotask
_loop_data
;
// FIXME: What is this checking?
if
(
*
data
)
.active
{
let
msg_po
=
*
((
*
data
)
.msg_po_ptr
);
...
...
@@ -190,8 +189,8 @@ unsafe fn send_high_level_msg(hl_loop: high_level_loop,
assert
loop_refs
==
1i32
;
}
fn
begin_teardown
(
data
:
*
hl
_loop_data
)
unsafe
{
log
(
debug
,
"
high_level_tear_
down() called, close async_handle"
);
fn
begin_teardown
(
data
:
*
iotask
_loop_data
)
unsafe
{
log
(
debug
,
"
iotask begin_tear
down() called, close async_handle"
);
// call user-suppled before_tear_down cb
let
async_handle
=
(
*
data
)
.async_handle
;
ll
::
close
(
async_handle
as
*
c_void
,
tear_down_close_cb
);
...
...
@@ -211,20 +210,20 @@ mod test {
ll
::
close
(
handle
,
async_close_cb
);
}
type
ah_data
=
{
hl_loop
:
high_level_loop
,
iotask
:
iotask
,
exit_ch
:
comm
::
chan
<
()
>
};
fn
impl_uv_
hl_async
(
hl_loop
:
high_level_loop
)
unsafe
{
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
=
comm
::
port
::
<
()
>
();
let
exit_ch
=
comm
::
chan
(
exit_po
);
let
ah_data
=
{
hl_loop
:
hl_loop
,
iotask
:
iotask
,
exit_ch
:
exit_ch
};
let
ah_data_ptr
=
ptr
::
addr_of
(
ah_data
);
interact
(
hl_loop
)
{|
loop_ptr
|
interact
(
iotask
)
{|
loop_ptr
|
ll
::
async_init
(
loop_ptr
,
ah_ptr
,
async_handle_cb
);
ll
::
set_data_for_uv_handle
(
ah_ptr
,
ah_data_ptr
as
*
libc
::
c_void
);
ll
::
async_send
(
ah_ptr
);
...
...
@@ -234,14 +233,14 @@ fn impl_uv_hl_async(hl_loop: high_level_loop) unsafe {
// this fn documents the bear minimum neccesary to roll your own
// high_level_loop
unsafe
fn
spawn_test_loop
(
exit_ch
:
comm
::
chan
<
()
>
)
->
high_level_loop
{
let
hl_loop_port
=
comm
::
port
::
<
high_level_loop
>
();
let
hl_loop_ch
=
comm
::
chan
(
hl_loop
_port
);
unsafe
fn
spawn_test_loop
(
exit_ch
:
comm
::
chan
<
()
>
)
->
iotask
{
let
iotask_port
=
comm
::
port
::
<
iotask
>
();
let
iotask_ch
=
comm
::
chan
(
iotask
_port
);
task
::
spawn_sched
(
task
::
manual_threads
(
1u
))
{||
run_
high_level_loop
(
hl_loop
_ch
);
run_
loop
(
iotask
_ch
);
exit_ch
.send
(());
};
ret
comm
::
recv
(
hl_loop
_port
);
ret
comm
::
recv
(
iotask
_port
);
}
crust
fn
lifetime_handle_close
(
handle
:
*
libc
::
c_void
)
unsafe
{
...
...
@@ -255,10 +254,10 @@ unsafe fn spawn_test_loop(exit_ch: comm::chan<()>) -> high_level_loop {
}
#[test]
fn
test_uv_
hl
_async
()
unsafe
{
fn
test_uv_
iotask
_async
()
unsafe
{
let
exit_po
=
comm
::
port
::
<
()
>
();
let
exit_ch
=
comm
::
chan
(
exit_po
);
let
hl_loop
=
spawn_test_loop
(
exit_ch
);
let
iotask
=
spawn_test_loop
(
exit_ch
);
// using this handle to manage the lifetime of the high_level_loop,
// as it will exit the first time one of the impl_uv_hl_async() is
...
...
@@ -270,7 +269,7 @@ fn test_uv_hl_async() unsafe {
let
work_exit_ch
=
comm
::
chan
(
work_exit_po
);
iter
::
repeat
(
7u
)
{||
task
::
spawn_sched
(
task
::
manual_threads
(
1u
),
{||
impl_uv_
hl_async
(
hl_loop
);
impl_uv_
iotask_async
(
iotask
);
comm
::
send
(
work_exit_ch
,
());
});
};
...
...
@@ -278,13 +277,7 @@ fn test_uv_hl_async() unsafe {
comm
::
recv
(
work_exit_po
);
};
log
(
debug
,
"sending teardown_loop msg.."
);
// the teardown msg usually comes, in the case of the global loop,
// as a result of receiving a msg on the weaken_task port. but,
// anyone rolling their own high_level_loop can decide when to
// send the msg. it's assert and barf, though, if all of your
// handles aren't uv_close'd first
comm
::
send
(
hl_loop
.op_chan
,
teardown_loop
);
ll
::
async_send
(
hl_loop
.async_handle
);
exit
(
iotask
);
comm
::
recv
(
exit_po
);
log
(
debug
,
"after recv on exit_po.. exiting.."
);
}
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录