Crate cancellable

This crate provides a way of defining an interface for a background service.

The main entrypoint of this create is cancellable::Cancellable trait. It is an async-trait that depends on tokio.

Examples

use std::{error::Error, net::SocketAddr};

use cancellable::{async_trait, Cancellable, CancellationResult};
use tokio::net::{TcpListener, TcpStream};

struct Listener {
    tcp_listener: TcpListener,
}

impl Listener {
    async fn new() -> Result<Self, Box<dyn Error>> {
        let tcp_listener = TcpListener::bind("127.0.0.1:5000").await?;

        Ok(Self { tcp_listener })
    }
}

#[async_trait]
impl Cancellable for Listener {
    type Result = (TcpStream, SocketAddr);
    type Handle = ();
    type Error = std::io::Error;

    async fn new_handle(&mut self) -> Self::Handle {}

    async fn run(&mut self) -> Result<CancellationResult<Self::Result>, Self::Error> {
        let (addr, stream) = self.tcp_listener.accept().await?;

        Ok(CancellationResult::item((addr, stream)))
    }
}

Structs

CancellableHandle

Service handle that allows to await for the service to join after it has been cancelled.

CancellationToken

A token which can be used to signal a cancellation request to one or more tasks.

Enums

CancellationResult

Result of a single iteration of the service loop.

Traits

Cancellable

Defines an interface for a cancellable service with an optional callback.

Attribute Macros

async_trait