pub trait Service<Request> {
type Response;
type Error;
type Future: Future<Output = Result<Self::Response, Self::Error>>;
// Required method
fn call(&self, req: Request) -> Self::Future;
}
Expand description
An asynchronous function from a Request
to a Response
.
The Service
trait is a simplified interface making it easy to write
network applications in a modular and reusable way, decoupled from the
underlying protocol.
§Functional
A Service
is a function of a Request
. It immediately returns a
Future
representing the eventual completion of processing the
request. The actual request processing may happen at any time in the
future, on any thread or executor. The processing may depend on calling
other services. At some point in the future, the processing will complete,
and the Future
will resolve to a response or error.
At a high level, the Service::call
function represents an RPC request. The
Service
value can be a server or a client.
Required Associated Types§
sourcetype Error
type Error
Errors produced by the service.
Note: Returning an Error
to a hyper server, the behavior depends on the
protocol. In most cases, hyper will cause the connection to be abruptly aborted.
It will abort the request however the protocol allows, either with some sort of RST_STREAM,
or killing the connection if that doesn’t exist.
Required Methods§
sourcefn call(&self, req: Request) -> Self::Future
fn call(&self, req: Request) -> Self::Future
Process the request and return the response asynchronously.
call
takes &self
instead of mut &self
because:
- It prepares the way for async fn,
since then the future only borrows
&self
, and thus a Service can concurrently handle multiple outstanding requests at once. - It’s clearer that Services can likely be cloned
- To share state across clones, you generally need
Arc<Mutex<_>>
That means you’re not really using the&mut self
and could do with a&self
. The discussion on this is here: https://github.com/hyperium/hyper/issues/3040