201cab84e8
There are a few reasons that this is a desirable move to take: 1. Proof of concept that a third party event loop is possible 2. Clear separation of responsibility between rt::io and the uv-backend 3. Enforce in the future that the event loop is "pluggable" and replacable Here's a quick summary of the points of this pull request which make this possible: * Two new lang items were introduced: event_loop, and event_loop_factory. The idea of a "factory" is to define a function which can be called with no arguments and will return the new event loop as a trait object. This factory is emitted to the crate map when building an executable. The factory doesn't have to exist, and when it doesn't then an empty slot is in the crate map and a basic event loop with no I/O support is provided to the runtime. * When building an executable, then the rustuv crate will be linked by default (providing a default implementation of the event loop) via a similar method to injecting a dependency on libstd. This is currently the only location where the rustuv crate is ever linked. * There is a new #[no_uv] attribute (implied by #[no_std]) which denies implicitly linking to rustuv by default Closes #5019
83 lines
2.6 KiB
Rust
83 lines
2.6 KiB
Rust
// 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 std::libc::c_int;
|
|
|
|
use uvll;
|
|
use super::{Watcher, Loop, NativeHandle, AsyncCallback, WatcherInterop};
|
|
use super::status_to_maybe_uv_error;
|
|
|
|
pub struct AsyncWatcher(*uvll::uv_async_t);
|
|
impl Watcher for AsyncWatcher { }
|
|
|
|
impl AsyncWatcher {
|
|
pub fn new(loop_: &mut Loop, cb: AsyncCallback) -> AsyncWatcher {
|
|
unsafe {
|
|
let handle = uvll::malloc_handle(uvll::UV_ASYNC);
|
|
assert!(handle.is_not_null());
|
|
let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
|
|
watcher.install_watcher_data();
|
|
let data = watcher.get_watcher_data();
|
|
data.async_cb = Some(cb);
|
|
assert_eq!(0, uvll::async_init(loop_.native_handle(), handle, async_cb));
|
|
return watcher;
|
|
}
|
|
|
|
extern fn async_cb(handle: *uvll::uv_async_t, status: c_int) {
|
|
let mut watcher: AsyncWatcher = NativeHandle::from_native_handle(handle);
|
|
let status = status_to_maybe_uv_error(status);
|
|
let data = watcher.get_watcher_data();
|
|
let cb = data.async_cb.get_ref();
|
|
(*cb)(watcher, status);
|
|
}
|
|
}
|
|
|
|
pub fn send(&mut self) {
|
|
unsafe {
|
|
let handle = self.native_handle();
|
|
uvll::async_send(handle);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl NativeHandle<*uvll::uv_async_t> for AsyncWatcher {
|
|
fn from_native_handle(handle: *uvll::uv_async_t) -> AsyncWatcher {
|
|
AsyncWatcher(handle)
|
|
}
|
|
fn native_handle(&self) -> *uvll::uv_async_t {
|
|
match self { &AsyncWatcher(ptr) => ptr }
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
|
|
use super::*;
|
|
use Loop;
|
|
use std::unstable::run_in_bare_thread;
|
|
use std::rt::thread::Thread;
|
|
use std::cell::Cell;
|
|
|
|
#[test]
|
|
fn smoke_test() {
|
|
do run_in_bare_thread {
|
|
let mut loop_ = Loop::new();
|
|
let watcher = AsyncWatcher::new(&mut loop_, |w, _| w.close(||()) );
|
|
let watcher_cell = Cell::new(watcher);
|
|
let thread = do Thread::start {
|
|
let mut watcher = watcher_cell.take();
|
|
watcher.send();
|
|
};
|
|
loop_.run();
|
|
loop_.close();
|
|
thread.join();
|
|
}
|
|
}
|
|
}
|