Struct aws_smithy_http_server::Router

pub struct Router<B = Body> { /* private fields */ }

The router is a [tower::Service] that routes incoming requests to other Services based on the request’s URI and HTTP method or on some specific header setting the target operation. The former is adhering to the Smithy specification, while the latter is adhering to the AwsJson specification.

The router is also Protocol aware and currently supports REST based protocols like restJson1 or restXml and RPC based protocols like awsJson1.0 or awsJson1.1. It currently does not support Smithy’s endpoint trait.

You should not instantiate this router directly; it will be created for you from the code generated from your Smithy model by smithy-rs.

Implementations

impl<B> Router<B> where
    B: Send + 'static, 

pub fn into_make_service(self) -> IntoMakeService<Self>

Convert this router into a MakeService, that is a [Service] whose response is another service.

This is useful when running your application with hyper’s Server.

pub fn layer<L, NewReqBody, NewResBody>(self, layer: L) -> Router<NewReqBody> where
    L: Layer<Route<B>>,
    L::Service: Service<Request<NewReqBody>, Response = Response<NewResBody>, Error = Infallible> + Clone + Send + 'static,
    <L::Service as Service<Request<NewReqBody>>>::Future: Send + 'static,
    NewResBody: HttpBody<Data = Bytes> + Send + 'static,
    NewResBody::Error: Into<Box<dyn StdError + Send + Sync>>, 

Apply a tower::Layer to the router.

All requests to the router will be processed by the layer’s corresponding middleware.

This can be used to add additional processing to all routes.

Trait Implementations

impl<B> Clone for Router<B>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<B: Debug> Debug for Router<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<B> Service<Request<B>> for Router<B> where
    B: Send + 'static, 

type Response = Response<UnsyncBoxBody<Bytes, Error>>

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = RouterFuture<B>

The future response value.

fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self::Error>>

Returns Poll::Ready(Ok(())) when the service is able to process requests.

fn call(&mut self, req: Request<B>) -> Self::Future

Process the request and return the response asynchronously.