Skip to content

Commit 56c2755

Browse files
alexcrichtonalexcrichton
committed
Assorted test fixes and merge conflicts
1 parent 173365c commit 56c2755

File tree

8 files changed

+134
-144
lines changed

8 files changed

+134
-144
lines changed

‎src/librustuv/file.rs

Lines changed: 32 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -95,27 +95,6 @@ impl FsRequest {
9595
}
9696
}
9797

98-
pub fn close(loop_: &Loop, fd: c_int, sync: bool) -> Result<(), UvError> {
99-
if sync {
100-
execute_nop(|req, cb| unsafe {
101-
uvll::uv_fs_close(loop_.handle, req, fd, cb)
102-
})
103-
} else {
104-
unsafe {
105-
let req = uvll::malloc_req(uvll::UV_FS);
106-
uvll::uv_fs_close(loop_.handle, req, fd, close_cb);
107-
return Ok(());
108-
}
109-
110-
extern fn close_cb(req: *uvll::uv_fs_t) {
111-
unsafe {
112-
uvll::uv_fs_req_cleanup(req);
113-
uvll::free_req(req);
114-
}
115-
}
116-
}
117-
}
118-
11998
pub fn mkdir(loop_: &Loop, path: &CString, mode: c_int)
12099
-> Result<(), UvError>
121100
{
@@ -240,10 +219,12 @@ impl FsRequest {
240219
pub fn utime(loop_: &Loop, path: &CString, atime: u64, mtime: u64)
241220
-> Result<(), UvError>
242221
{
222+
// libuv takes seconds
223+
let atime = atime as libc::c_double / 1000.0;
224+
let mtime = mtime as libc::c_double / 1000.0;
243225
execute_nop(|req, cb| unsafe {
244226
uvll::uv_fs_utime(loop_.handle, req, path.with_ref(|p| p),
245-
atime as libc::c_double, mtime as libc::c_double,
246-
cb)
227+
atime, mtime, cb)
247228
})
248229
}
249230

@@ -368,12 +349,12 @@ impl FileWatcher {
368349
}
369350

370351
fn base_read(&mut self, buf: &mut [u8], offset: i64) -> Result<int, IoError> {
371-
let _m = self.fire_missiles();
352+
let _m = self.fire_homing_missile();
372353
let r = FsRequest::read(&self.loop_, self.fd, buf, offset);
373354
r.map_err(uv_error_to_io_error)
374355
}
375356
fn base_write(&mut self, buf: &[u8], offset: i64) -> Result<(), IoError> {
376-
let _m = self.fire_missiles();
357+
let _m = self.fire_homing_missile();
377358
let r = FsRequest::write(&self.loop_, self.fd, buf, offset);
378359
r.map_err(uv_error_to_io_error)
379360
}
@@ -397,14 +378,26 @@ impl FileWatcher {
397378

398379
impl Drop for FileWatcher {
399380
fn drop(&mut self) {
400-
let _m = self.fire_missiles();
381+
let _m = self.fire_homing_missile();
401382
match self.close {
402383
rtio::DontClose => {}
403384
rtio::CloseAsynchronously => {
404-
FsRequest::close(&self.loop_, self.fd, false);
385+
unsafe {
386+
let req = uvll::malloc_req(uvll::UV_FS);
387+
uvll::uv_fs_close(self.loop_.handle, req, self.fd, close_cb);
388+
}
389+
390+
extern fn close_cb(req: *uvll::uv_fs_t) {
391+
unsafe {
392+
uvll::uv_fs_req_cleanup(req);
393+
uvll::free_req(req);
394+
}
395+
}
405396
}
406397
rtio::CloseSynchronously => {
407-
FsRequest::close(&self.loop_, self.fd, true);
398+
execute_nop(|req, cb| unsafe {
399+
uvll::uv_fs_close(self.loop_.handle, req, self.fd, cb)
400+
});
408401
}
409402
}
410403
}
@@ -439,15 +432,15 @@ impl rtio::RtioFileStream for FileWatcher {
439432
self_.seek_common(0, SEEK_CUR)
440433
}
441434
fn fsync(&mut self) -> Result<(), IoError> {
442-
let _m = self.fire_missiles();
435+
let _m = self.fire_homing_missile();
443436
FsRequest::fsync(&self.loop_, self.fd).map_err(uv_error_to_io_error)
444437
}
445438
fn datasync(&mut self) -> Result<(), IoError> {
446-
let _m = self.fire_missiles();
439+
let _m = self.fire_homing_missile();
447440
FsRequest::datasync(&self.loop_, self.fd).map_err(uv_error_to_io_error)
448441
}
449442
fn truncate(&mut self, offset: i64) -> Result<(), IoError> {
450-
let _m = self.fire_missiles();
443+
let _m = self.fire_homing_missile();
451444
let r = FsRequest::truncate(&self.loop_, self.fd, offset);
452445
r.map_err(uv_error_to_io_error)
453446
}
@@ -482,10 +475,6 @@ mod test {
482475
// write
483476
let result = FsRequest::write(l, fd, "hello".as_bytes(), -1);
484477
assert!(result.is_ok());
485-
486-
// close
487-
let result = FsRequest::close(l, fd, true);
488-
assert!(result.is_ok());
489478
}
490479

491480
{
@@ -505,15 +494,10 @@ mod test {
505494
assert!(nread > 0);
506495
let read_str = str::from_utf8(read_mem.slice(0, nread as uint));
507496
assert_eq!(read_str, ~"hello");
508-
509-
// close
510-
let result = FsRequest::close(l, fd, true);
511-
assert!(result.is_ok());
512-
513-
// unlink
514-
let result = FsRequest::unlink(l, &path_str.to_c_str());
515-
assert!(result.is_ok());
516497
}
498+
// unlink
499+
let result = FsRequest::unlink(l, &path_str.to_c_str());
500+
assert!(result.is_ok());
517501
}
518502
}
519503
@@ -570,12 +554,14 @@ mod test {
570554
let path = &"./tmp/double_create_dir".to_c_str();
571555
let mode = S_IWUSR | S_IRUSR;
572556
557+
let result = FsRequest::stat(l, path);
558+
assert!(result.is_err(), "{:?}", result);
573559
let result = FsRequest::mkdir(l, path, mode as c_int);
574-
assert!(result.is_ok());
560+
assert!(result.is_ok(), "{:?}", result);
575561
let result = FsRequest::mkdir(l, path, mode as c_int);
576-
assert!(result.is_err());
562+
assert!(result.is_err(), "{:?}", result);
577563
let result = FsRequest::rmdir(l, path);
578-
assert!(result.is_ok());
564+
assert!(result.is_ok(), "{:?}", result);
579565
}
580566
}
581567

‎src/librustuv/net.rs

Lines changed: 29 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -259,51 +259,51 @@ impl HomingIO for TcpWatcher {
259259

260260
impl rtio::RtioSocket for TcpWatcher {
261261
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
262-
let _m = self.fire_missiles();
262+
let _m = self.fire_homing_missile();
263263
socket_name(Tcp, self.handle)
264264
}
265265
}
266266

267267
impl rtio::RtioTcpStream for TcpWatcher {
268268
fn read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
269-
let _m = self.fire_missiles();
269+
let _m = self.fire_homing_missile();
270270
self.stream.read(buf).map_err(uv_error_to_io_error)
271271
}
272272

273273
fn write(&mut self, buf: &[u8]) -> Result<(), IoError> {
274-
let _m = self.fire_missiles();
274+
let _m = self.fire_homing_missile();
275275
self.stream.write(buf).map_err(uv_error_to_io_error)
276276
}
277277

278278
fn peer_name(&mut self) -> Result<SocketAddr, IoError> {
279-
let _m = self.fire_missiles();
279+
let _m = self.fire_homing_missile();
280280
socket_name(TcpPeer, self.handle)
281281
}
282282

283283
fn control_congestion(&mut self) -> Result<(), IoError> {
284-
let _m = self.fire_missiles();
284+
let _m = self.fire_homing_missile();
285285
status_to_io_result(unsafe {
286286
uvll::uv_tcp_nodelay(self.handle, 0 as c_int)
287287
})
288288
}
289289

290290
fn nodelay(&mut self) -> Result<(), IoError> {
291-
let _m = self.fire_missiles();
291+
let _m = self.fire_homing_missile();
292292
status_to_io_result(unsafe {
293293
uvll::uv_tcp_nodelay(self.handle, 1 as c_int)
294294
})
295295
}
296296

297297
fn keepalive(&mut self, delay_in_seconds: uint) -> Result<(), IoError> {
298-
let _m = self.fire_missiles();
298+
let _m = self.fire_homing_missile();
299299
status_to_io_result(unsafe {
300300
uvll::uv_tcp_keepalive(self.handle, 1 as c_int,
301301
delay_in_seconds as c_uint)
302302
})
303303
}
304304

305305
fn letdie(&mut self) -> Result<(), IoError> {
306-
let _m = self.fire_missiles();
306+
let _m = self.fire_homing_missile();
307307
status_to_io_result(unsafe {
308308
uvll::uv_tcp_keepalive(self.handle, 0 as c_int, 0 as c_uint)
309309
})
@@ -312,7 +312,7 @@ impl rtio::RtioTcpStream for TcpWatcher {
312312

313313
impl Drop for TcpWatcher {
314314
fn drop(&mut self) {
315-
let _m = self.fire_missiles();
315+
let _m = self.fire_homing_missile();
316316
self.stream.close();
317317
}
318318
}
@@ -356,7 +356,7 @@ impl UvHandle<uvll::uv_tcp_t> for TcpListener {
356356

357357
impl rtio::RtioSocket for TcpListener {
358358
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
359-
let _m = self.fire_missiles();
359+
let _m = self.fire_homing_missile();
360360
socket_name(Tcp, self.handle)
361361
}
362362
}
@@ -370,7 +370,7 @@ impl rtio::RtioTcpListener for TcpListener {
370370
incoming: incoming,
371371
};
372372

373-
let _m = acceptor.fire_missiles();
373+
let _m = acceptor.fire_homing_missile();
374374
// XXX: the 128 backlog should be configurable
375375
match unsafe { uvll::uv_listen(acceptor.listener.handle, 128, listen_cb) } {
376376
0 => Ok(acceptor as ~rtio::RtioTcpAcceptor),
@@ -399,7 +399,7 @@ extern fn listen_cb(server: *uvll::uv_stream_t, status: c_int) {
399399

400400
impl Drop for TcpListener {
401401
fn drop(&mut self) {
402-
let (_m, sched) = self.fire_missiles_sched();
402+
let (_m, sched) = self.fire_homing_missile_sched();
403403

404404
do sched.deschedule_running_task_and_then |_, task| {
405405
self.closing_task = Some(task);
@@ -424,26 +424,26 @@ impl HomingIO for TcpAcceptor {
424424

425425
impl rtio::RtioSocket for TcpAcceptor {
426426
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
427-
let _m = self.fire_missiles();
427+
let _m = self.fire_homing_missile();
428428
socket_name(Tcp, self.listener.handle)
429429
}
430430
}
431431

432432
impl rtio::RtioTcpAcceptor for TcpAcceptor {
433433
fn accept(&mut self) -> Result<~rtio::RtioTcpStream, IoError> {
434-
let _m = self.fire_missiles();
434+
let _m = self.fire_homing_missile();
435435
self.incoming.recv()
436436
}
437437

438438
fn accept_simultaneously(&mut self) -> Result<(), IoError> {
439-
let _m = self.fire_missiles();
439+
let _m = self.fire_homing_missile();
440440
status_to_io_result(unsafe {
441441
uvll::uv_tcp_simultaneous_accepts(self.listener.handle, 1)
442442
})
443443
}
444444

445445
fn dont_accept_simultaneously(&mut self) -> Result<(), IoError> {
446-
let _m = self.fire_missiles();
446+
let _m = self.fire_homing_missile();
447447
status_to_io_result(unsafe {
448448
uvll::uv_tcp_simultaneous_accepts(self.listener.handle, 0)
449449
})
@@ -489,7 +489,7 @@ impl HomingIO for UdpWatcher {
489489

490490
impl rtio::RtioSocket for UdpWatcher {
491491
fn socket_name(&mut self) -> Result<SocketAddr, IoError> {
492-
let _m = self.fire_missiles();
492+
let _m = self.fire_homing_missile();
493493
socket_name(Udp, self.handle)
494494
}
495495
}
@@ -503,7 +503,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
503503
buf: Option<Buf>,
504504
result: Option<(ssize_t, SocketAddr)>,
505505
}
506-
let _m = self.fire_missiles();
506+
let _m = self.fire_homing_missile();
507507

508508
return match unsafe {
509509
uvll::uv_udp_recv_start(self.handle, alloc_cb, recv_cb)
@@ -564,7 +564,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
564564
fn sendto(&mut self, buf: &[u8], dst: SocketAddr) -> Result<(), IoError> {
565565
struct Ctx { task: Option<BlockedTask>, result: c_int }
566566

567-
let _m = self.fire_missiles();
567+
let _m = self.fire_homing_missile();
568568

569569
let req = Request::new(uvll::UV_UDP_SEND);
570570
let buf = slice_to_uv_buf(buf);
@@ -607,7 +607,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
607607
}
608608

609609
fn join_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
610-
let _m = self.fire_missiles();
610+
let _m = self.fire_homing_missile();
611611
status_to_io_result(unsafe {
612612
do multi.to_str().with_c_str |m_addr| {
613613
uvll::uv_udp_set_membership(self.handle,
@@ -618,7 +618,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
618618
}
619619

620620
fn leave_multicast(&mut self, multi: IpAddr) -> Result<(), IoError> {
621-
let _m = self.fire_missiles();
621+
let _m = self.fire_homing_missile();
622622
status_to_io_result(unsafe {
623623
do multi.to_str().with_c_str |m_addr| {
624624
uvll::uv_udp_set_membership(self.handle,
@@ -629,46 +629,46 @@ impl rtio::RtioUdpSocket for UdpWatcher {
629629
}
630630

631631
fn loop_multicast_locally(&mut self) -> Result<(), IoError> {
632-
let _m = self.fire_missiles();
632+
let _m = self.fire_homing_missile();
633633
status_to_io_result(unsafe {
634634
uvll::uv_udp_set_multicast_loop(self.handle,
635635
1 as c_int)
636636
})
637637
}
638638

639639
fn dont_loop_multicast_locally(&mut self) -> Result<(), IoError> {
640-
let _m = self.fire_missiles();
640+
let _m = self.fire_homing_missile();
641641
status_to_io_result(unsafe {
642642
uvll::uv_udp_set_multicast_loop(self.handle,
643643
0 as c_int)
644644
})
645645
}
646646

647647
fn multicast_time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
648-
let _m = self.fire_missiles();
648+
let _m = self.fire_homing_missile();
649649
status_to_io_result(unsafe {
650650
uvll::uv_udp_set_multicast_ttl(self.handle,
651651
ttl as c_int)
652652
})
653653
}
654654

655655
fn time_to_live(&mut self, ttl: int) -> Result<(), IoError> {
656-
let _m = self.fire_missiles();
656+
let _m = self.fire_homing_missile();
657657
status_to_io_result(unsafe {
658658
uvll::uv_udp_set_ttl(self.handle, ttl as c_int)
659659
})
660660
}
661661

662662
fn hear_broadcasts(&mut self) -> Result<(), IoError> {
663-
let _m = self.fire_missiles();
663+
let _m = self.fire_homing_missile();
664664
status_to_io_result(unsafe {
665665
uvll::uv_udp_set_broadcast(self.handle,
666666
1 as c_int)
667667
})
668668
}
669669

670670
fn ignore_broadcasts(&mut self) -> Result<(), IoError> {
671-
let _m = self.fire_missiles();
671+
let _m = self.fire_homing_missile();
672672
status_to_io_result(unsafe {
673673
uvll::uv_udp_set_broadcast(self.handle,
674674
0 as c_int)
@@ -679,7 +679,7 @@ impl rtio::RtioUdpSocket for UdpWatcher {
679679
impl Drop for UdpWatcher {
680680
fn drop(&mut self) {
681681
// Send ourselves home to close this handle (blocking while doing so).
682-
let (_m, sched) = self.fire_missiles_sched();
682+
let (_m, sched) = self.fire_homing_missile_sched();
683683
let mut slot = None;
684684
unsafe {
685685
uvll::set_data_for_uv_handle(self.handle, &slot);
@@ -693,6 +693,7 @@ impl Drop for UdpWatcher {
693693
let slot: &mut Option<BlockedTask> = unsafe {
694694
cast::transmute(uvll::get_data_for_uv_handle(handle))
695695
};
696+
unsafe { uvll::free_handle(handle) }
696697
let sched: ~Scheduler = Local::take();
697698
sched.resume_blocked_task_immediately(slot.take_unwrap());
698699
}

0 commit comments

Comments
 (0)