Struct ConcurrentService 

pub struct ConcurrentService<S>
where
    S: SimpleService + Clone + Send + Sync,
{ /* private fields */ }

A service that handles messages concurrently.

When the service reaches its maximum concurrency, it either drops messages or keeps them in the input queue.

use relay_system::{Interface, SimpleService, LoadShed, ConcurrentService};

#[derive(Clone)]
struct MyService;

struct MyMessage;
impl Interface for MyMessage {}

impl SimpleService for MyService {
    type Interface = MyMessage;
    async fn handle_message(&self, message: MyMessage) {
        // do your thing
    }
}

// `Loadshed` implementation is required but can be empty.
impl LoadShed<MyMessage> for MyService {
    fn handle_loadshed(&self, _: MyMessage) {
        eprintln!("Dropped a message!");
    }
}

let concurrent_service = ConcurrentService::new(MyService).with_concurrency_limit(5);

Implementations

impl<S> ConcurrentService<S>

where S: SimpleService + Clone + Send + Sync,

pub fn new(inner: S) -> Self

Creates a new concurrent service from a SimpleService.

The default strategy for congestion control is to keep messages in the input queue.

pub fn with_concurrency_limit(self, limit: usize) -> Self

Sets the maximum number of messages that can be handled concurrently.

pub fn with_backlog_limit(self, limit: usize) -> Self

Limits the amount of messages that wait in the queue by loadshedding.

Setting this limit will cause message loss.

Note that cleanup of the queue may be deferred until the next pending future completes.

Trait Implementations

impl<S> Service for ConcurrentService<S>

where S: SimpleService + LoadShed<S::Interface> + Clone + Send + Sync + 'static,

type Interface = <S as SimpleService>::Interface

The interface of messages this service implements.

async fn run(self, rx: Receiver<Self::Interface>)

Defines the main task of this service.

fn start_detached(self) -> Addr<Self::Interface>

Starts the service in the current runtime and returns an address for it.

fn name() -> &'static str

Returns a unique name for this service implementation.