Struct interledger_service_util::RateLimitService

pub struct RateLimitService<S, I, A> { /* fields omitted */ }

Rate Limit Service

Incoming Service responsible for rejecting requests by users who have reached their account's rate limit. Talks with the associated Store in order to figure out and set the rate limits per account. This service does packet based limiting and amount based limiting.

Forwards everything else. Requires a RateLimitAccount and a RateLimitStore. It is an IncomingService.

Methods

impl<S, I, A> RateLimitService<S, I, A> where
    S: AddressStore + RateLimitStore<Account = A> + Clone + Send + Sync,
    I: IncomingService<A> + Clone + Send + Sync,
    A: RateLimitAccount + Sync, 

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

Trait Implementations

impl<S: Clone, I: Clone, A: Clone> Clone for RateLimitService<S, I, A>

fn clone(&self) -> RateLimitService<S, I, A>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, I, A> IncomingService<A> for RateLimitService<S, I, A> where
    S: AddressStore + RateLimitStore<Account = A> + Clone + Send + Sync + 'static,
    I: IncomingService<A> + Clone + Send + Sync + 'static,
    A: RateLimitAccount + Sync + 'static, 

type Future = BoxedIlpFuture

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

On receiving a request:

1. Apply rate limit based on the sender of the request and the amount in the prepare packet in the request
2. If no limits were hit forward the request
   • If it succeeds, OK
   • If the request forwarding failed, the client should not be charged towards their throughput limit, so they are refunded, and return a reject
3. If the limit was hit, return a reject with the appropriate ErrorCode.