Struct interledger_router::Router

pub struct Router<S, O> { /* fields omitted */ }

Interledger Router

The Router implements an incoming service and includes an outgoing service. It determines the next account to forward to and passes it on. Both incoming and outgoing services can respond to requests but many just pass the request on. The Router requires a RouterStore, which keeps track of the entire routing table. Once the Router receives a Prepare, it checks its destination and if it finds it in the routing table

The router implements the IncomingService trait and uses the routing table to determine the to (or "next hop") Account for the given request.

Note that the router does not:

• apply exchange rates or fees to the Prepare packet
• adjust account balances
• reduce the Prepare packet's expiry

That is done by OutgoingServices.

Methods

impl<S, O> Router<S, O> where
    S: RouterStore,
    O: OutgoingService<S::Account>, 

pub fn new(store: S, next: O) -> Self

Trait Implementations

impl<S: Clone, O: Clone> Clone for Router<S, O>

fn clone(&self) -> Router<S, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, O> IncomingService<<S as AccountStore>::Account> for Router<S, O> where
    S: AddressStore + RouterStore,
    O: OutgoingService<S::Account> + Clone + Send + 'static, 

type Future = BoxedIlpFuture

fn handle_request(
    &mut self,
    request: IncomingRequest<S::Account>
) -> Self::Future

Figures out the next node to pass the received Prepare packet to.

Firstly, it checks if there is a direct path for that account and uses that. If not it scans through the routing table and checks if the route prefix matches the prepare packet's destination or if it's a catch-all address (i.e. empty prefix)

fn wrap<F, R>(self, f: F) -> WrappedService<F, Self, A> where
    F: Fn(IncomingRequest<A>, Self) -> R,
    R: Future<Item = Fulfill, Error = Reject> + Send + 'static,
    Self: Clone, 

Wrap the given service such that the provided function will be called to handle each request. That function can return immediately, modify the request before passing it on, and/or handle the result of calling the inner service.