57974ae0b7
* Use non-blocking connect for TcpStream.
Instead of spawning a background thread which is unaware of any timeouts
but continues to run until the TCP stack decides that the remote is not
reachable we use mio's non-blocking connect.
mio's `TcpStream::connect` returns immediately but the actual connection
is usually just in progress and we have to be sure the socket is
writeable before we can consider the connection as established.
* Add Watcher::{poll_read_ready, poll_write_ready}.
Following a suggestion of @stjepang we offer methods to check for
read/write readiness of a `Watcher` instead of the previous approach to
accept a set of `Waker`s when registering an event source. The changes
relative to master are smaller and both methods look more useful in
other contexts. Also the code is more robust w.r.t. wakeups of the
`Waker` from clones outside the `Reactor`.
I am not sure if we need to add protection mechanisms against spurious
wakeups from mio. Currently we treat the `Poll::Ready(())` of
`Watcher::poll_write_ready` as proof that the non-blocking connect has
finished, but if the event from mio was a spurious one, it might still
be ongoing.
|
||
|---|---|---|
| .github | ||
| benches | ||
| ci | ||
| docs | ||
| examples | ||
| src | ||
| tests | ||
| .gitignore | ||
| bors.toml | ||
| Cargo.toml | ||
| CHANGELOG.md | ||
| CODE_OF_CONDUCT.md | ||
| LICENSE-APACHE | ||
| LICENSE-MIT | ||
| README.md | ||
| rustfmt.toml | ||
async-std
API Docs | Book | Releases | Contributing
This crate provides an async version of std. It provides all the interfaces
you are used to, but in an async version and ready for Rust's async/await
syntax.
Features
- Modern: Built from the ground up for
std::futureandasync/awaitwith blazing fast compilation time. - Fast: Our robust allocator and threadpool designs provide ultra-high throughput with predictably low latency.
- Intuitive: Complete parity with the stdlib means you only need to learn APIs once.
- Clear: Detailed documentation and accessible guides mean using async Rust was never easier.
Examples
use async_std::task;
async fn say_hello() {
println!("Hello, world!");
}
fn main() {
task::block_on(say_hello())
}
More examples, including networking and file access, can be found in our
examples directory and in our documentation.
Philosophy
We believe Async Rust should be as easy to pick up as Sync Rust. We also believe that the best API is the one you already know. And finally, we believe that providing an asynchronous counterpart to the standard library is the best way stdlib provides a reliable basis for both performance and productivity.
Async-std is the embodiment of that vision. It combines single-allocation task creation, with an adaptive lock-free executor, threadpool and network driver to create a smooth system that processes work at a high pace with low latency, using Rust's familiar stdlib API.
Installation
With cargo add installed run:
$ cargo add async-std
We also provide a set of "unstable" features with async-std. See the features documentation on how to enable them.
Ecosystem
-
async-tls — Async TLS/SSL streams using Rustls.
-
async-native-tls — Native TLS for Async. Native TLS for futures and async-std.
-
async-tungstenite — Asynchronous WebSockets for async-std, tokio, gio and any std Futures runtime.
-
Tide — Serve the web. A modular web framework built around async/await.
-
SQLx — The Rust SQL Toolkit. SQLx is a 100% safe Rust library for Postgres and MySQL with compile-time checked queries.
-
Surf — Surf the web. Surf is a friendly HTTP client built for casual Rustaceans and veterans alike.
License
Licensed under either of Apache License, Version 2.0 or MIT license at your option.Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this crate by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.