7 unstable releases (3 breaking)
0.3.2 | Feb 15, 2023 |
---|---|
0.3.1 | Feb 9, 2023 |
0.3.0 | Dec 22, 2022 |
0.2.1 | Oct 18, 2022 |
0.0.0 | Jun 7, 2022 |
#82 in Asynchronous
378 downloads per month
Used in 4 crates
51KB
1K
SLoC
Motore is an async middleware abstraction powered by GAT and TAIT.
Around Motore, we build modular and reusable components for building robust networking clients and servers.
Motore is greatly inspired by Tower
.
Overview
Motore uses GAT and TAIT to reduce the mental burden of writing asynchronous code, especially to avoid the overhead of Box
to make people less anxious.
The core abstraciton of Motore is the Service
trait:
pub trait Service<Cx, Request> {
/// Responses given by the service.
type Response;
/// Errors produced by the service.
type Error;
/// The future response value.
type Future<'cx>: Future<Output = Result<Self::Response, Self::Error>> + Send + 'cx
where
Cx: 'cx,
Self: 'cx;
/// Process the request and return the response asynchronously.
fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Request) -> Self::Future<'cx>
where
's: 'cx;
}
Getting Started
Combing GAT and type_alias_impl_trait
together, we can write asynchronous code in a very concise and readable way.
pub struct Timeout<S> {
inner: S,
duration: Duration,
}
impl<Cx, Req, S> Service<Cx, Req> for Timeout<S>
where
Req: 'static + Send,
S: Service<Cx, Req> + 'static + Send + Sync,
Cx: 'static + Send,
S::Error: Send + Sync + Into<BoxError>,
{
type Response = S::Response;
type Error = BoxError;
type Future<'cx> = impl Future<Output = Result<S::Response, Self::Error>> + Send + 'cx;
fn call<'cx, 's>(&'s self, cx: &'cx mut Cx, req: Req) -> Self::Future<'cx>
where
's: 'cx,
{
async move {
let sleep = tokio::time::sleep(self.duration);
tokio::select! {
r = self.inner.call(cx, req) => {
r.map_err(Into::into)
},
_ = sleep => Err(std::io::Error::new(std::io::ErrorKind::TimedOut, "service time out").into()),
}
}
}
}
We also provided the #[motore::service]
macro to make writing a Serivce
more async-native:
use motore::service;
pub struct S<I> {
inner: I,
}
#[service]
impl<Cx, Req, I> Service<Cx, Req> for S<I>
where
Req: Send + 'static,
I: Service<Cx, Req> + Send + 'static + Sync,
Cx: Send + 'static,
{
async fn call(&self, cx: &mut Cx, req: Req) -> Result<I::Response, I::Error> {
self.inner.call(cx, req).await
}
}
FAQ
Why do we need GAT?
https://www.cloudwego.io/zh/docs/motore/faq/q1_gat/
Where's the poll_ready
(a.k.a. backpressure)?
https://www.cloudwego.io/zh/docs/motore/faq/q2_pull_ready/
License
Motore is dual-licensed under the MIT license and the Apache License (Version 2.0).
See LICENSE-MIT and LICENSE-APACHE for details.
Credits
We have used some third party components, and we thank them for their work.
For the full list, you may refer to the CREDITS.md file.
Community
-
Email: motore@cloudwego.io
-
How to become a member: COMMUNITY MEMBERSHIP
-
Issues: Issues
-
Feishu: Scan the QR code below with Feishu or click this link to join our CloudWeGo Motore user group.
Dependencies
~3–8MB
~126K SLoC