Struct Router 

pub struct Router<State: Clone + Send + Sync + 'static = ()> { /* private fields */ }

Available on (crate features clients or servers) and crate feature servers only.

A router that is capable of routing based on the prefixes of Layer 4 packets.

See the module documentation for more information about how exactly the routing happens, how backpressure is handled, and how narrowing down packets.

Routes themselves are arbitrary tower::Service’s, where the crate provides automatic conversions from async fn into services.

Implementations

impl<State: Clone + Send + Sync + 'static> Router<State>

pub fn new() -> Self

Create a new prefix routable router.

pub fn new_with_offset(offset_at: usize) -> Self

Create a new prefix routable router who treats a packet id at a particular offset.

pub fn add_route<HandlerTy, HandlerParamsTy>( &mut self, packet_start: &[u8], handle: HandlerTy, ) -> Result<(), CommonNetAPIError>

where HandlerTy: Handler<HandlerParamsTy, State> + Clone + Send + 'static, HandlerParamsTy: Send + 'static,

Add a route to be handled by the router, this accepts a Handler which most of the time is an async function.

This takes a packet_start which is a set of at most 16 bytes that can be matched against the configured byte offset of a packet to determine matching.

Errors

If the packet_start is already greater than 16 bytes, empty, or the route has already been registered.

pub fn add_route_service<ServiceTy>( &mut self, packet_start: &[u8], service: ServiceTy, ) -> Result<(), CommonNetAPIError>

where ServiceTy: Service<Request<State>, Response = Response, Error = CatBridgeError> + Clone + Send + 'static, ServiceTy::Future: Send,

Add a route to be processed for anything that implements Service.

This allows applying more generic tower services to the router directly. We expect the general case to still pass in functions which end up going to the [add_route]. AS the function gets cast to a handler.

Errors

If the packet_start is longer than 16 bytes long, or this route has already been registered.

pub fn layer<LayerTy, ServiceTy>(&mut self, layer: LayerTy)

where LayerTy: Layer<BoxCloneService<Request<State>, Response, CatBridgeError>, Service = ServiceTy>, ServiceTy: Service<Request<State>, Response = Response, Error = CatBridgeError> + Clone + Send + 'static, <LayerTy::Service as Service<Request<State>>>::Future: Send + 'static,

Apply a layer to all existing routes that currently exist in the router.

This as a result will not apply to future routes added to this router, and the last applied layers will run first. This may seem confusing at first but basically works the same way as in axum.

pub fn fallback_handler<HandlerTy, HandlerParamsTy>( &mut self, handle: HandlerTy, ) -> Result<(), CommonNetAPIError>

where HandlerTy: Handler<HandlerParamsTy, State> + Clone + Send + 'static, HandlerParamsTy: Send + 'static,

Set the handler to call when a route cannot be found.

Errors

If there is already a fallback handler registered.

pub fn fallback_handler_service<ServiceTy>( &mut self, service: ServiceTy, ) -> Result<(), CommonNetAPIError>

where ServiceTy: Service<Request<State>, Response = Response, Error = CatBridgeError> + Clone + Send + 'static, ServiceTy::Future: Send,

Set the handler to call when a route cannot be found.

Errors

If there is already a fallback handler registered.

Trait Implementations

impl<State: Clone + Clone + Send + Sync + 'static> Clone for Router<State>

fn clone(&self) -> Router<State>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<State: Debug + Clone + Send + Sync + 'static> Debug for Router<State>

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

Formats the value using the given formatter.

impl<State: Clone + Send + Sync + 'static> Default for Router<State>

fn default() -> Self

Returns the “default value” for a type.

impl<State: Clone + Send + Sync + 'static> Service<Request<State>> for Router<State>

type Response = Response

Responses given by the service.

type Error = Infallible

Errors produced by the service.

type Future = Pin<Box<dyn Future<Output = Result<<Router<State> as Service<Request<State>>>::Response, <Router<State> as Service<Request<State>>>::Error>> + Send>>

The future response value.

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

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

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

Process the request and return the response asynchronously.