Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/async-rs/async-std-hyper
How to run Hyper on async-std
https://github.com/async-rs/async-std-hyper
Last synced: about 2 months ago
JSON representation
How to run Hyper on async-std
- Host: GitHub
- URL: https://github.com/async-rs/async-std-hyper
- Owner: async-rs
- License: apache-2.0
- Created: 2020-02-09T10:28:28.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2022-09-04T16:15:24.000Z (about 2 years ago)
- Last Synced: 2024-04-22T13:24:12.936Z (5 months ago)
- Language: Rust
- Size: 12.7 KB
- Stars: 40
- Watchers: 4
- Forks: 4
- Open Issues: 3
-
Metadata Files:
- Readme: README.md
- License: LICENSE-APACHE
Awesome Lists containing this project
README
# How to run Hyper on async-std
This is a simple example showing how to run [`hyper`] on [`async-std`].
[`hyper`]: https://docs.rs/hyper
[`async-std`]: https://docs.rs/async-std## Instructions
#### Step 1: Dependencies
Add `async-std`, `hyper`, and `tokio` as dependencies to your crate:
```toml
[dependencies]
async-std = "1"
hyper = { version = "0.13", default-features = false }
tokio = { version = "0.2", default-features = false }
```#### Step 2: Compatibility layer
Copy this `compat` module into your crate:
```rust
pub mod compat {
use std::pin::Pin;
use std::task::{Context, Poll};use async_std::io;
use async_std::net::{TcpListener, TcpStream};
use async_std::prelude::*;
use async_std::task;#[derive(Clone)]
pub struct HyperExecutor;impl hyper::rt::Executor for HyperExecutor
where
F: Future + Send + 'static,
F::Output: Send + 'static,
{
fn execute(&self, fut: F) {
task::spawn(fut);
}
}pub struct HyperListener(pub TcpListener);
impl hyper::server::accept::Accept for HyperListener {
type Conn = HyperStream;
type Error = io::Error;fn poll_accept(
mut self: Pin<&mut Self>,
cx: &mut Context,
) -> Poll>> {
let stream = task::ready!(Pin::new(&mut self.0.incoming()).poll_next(cx)).unwrap()?;
Poll::Ready(Some(Ok(HyperStream(stream))))
}
}pub struct HyperStream(pub TcpStream);
impl tokio::io::AsyncRead for HyperStream {
fn poll_read(
mut self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut [u8],
) -> Poll> {
Pin::new(&mut self.0).poll_read(cx, buf)
}
}impl tokio::io::AsyncWrite for HyperStream {
fn poll_write(
mut self: Pin<&mut Self>,
cx: &mut Context,
buf: &[u8],
) -> Poll> {
Pin::new(&mut self.0).poll_write(cx, buf)
}fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll> {
Pin::new(&mut self.0).poll_flush(cx)
}fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll> {
Pin::new(&mut self.0).poll_close(cx)
}
}
}
```#### Step 3: Configure Hyper
Configure the `hyper` builder with:
```rust
let server = Server::builder(compat::HyperListener(listener))
.executor(compat::Executor);
```Full example:
```rust
use std::convert::Infallible;use async_std::net::TcpListener;
use async_std::task;
use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};use compat; // This is the module from Step 2.
async fn hello(_: Request) -> Result, Infallible> {
Ok(Response::new(Body::from("Hello World!")))
}fn main() -> Result<(), Box> {
task::block_on(async {
let addr = "127.0.0.1:3000";
let listener = TcpListener::bind(addr).await?;let make_svc = make_service_fn(|_conn| async { Ok::<_, Infallible>(service_fn(hello)) });
let server = Server::builder(compat::HyperListener(listener))
.executor(compat::HyperExecutor)
.serve(make_svc);println!("Listening on http://{}", addr);
server.await?;
Ok(())
})
}
```## 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.