Trait WebhookSender 

pub trait WebhookSender {
    type Message;
    type Error: Error;

    // Required method
    fn send(
        &self,
        message: &Self::Message,
    ) -> impl Future<Output = Result<(), Self::Error>> + Send;

    // Provided method
    fn send_batch<'a>(
        &'a self,
        messages: &'a [&'a Self::Message],
    ) -> impl Future<Output = Vec<Result<(), Self::Error>>> + Send + 'a
       where Self: Sync,
             Self::Error: Send { ... }
}

Common interface implemented by every hooksmith webhook client.

Each service crate defines its own Message and Error types and implements this trait. Application code can then be generic over the notification backend:

use hooksmith_core::WebhookSender;

async fn notify<S>(sender: &S, msg: &S::Message) -> Result<(), S::Error>
where
    S: WebhookSender,
{
    sender.send(msg).await
}

Required Associated Types

type Message

The message type accepted by this sender.

type Error: Error

The error type returned on failure.

Required Methods

fn send( &self, message: &Self::Message, ) -> impl Future<Output = Result<(), Self::Error>> + Send

Send a single message to the configured webhook endpoint.

Provided Methods

fn send_batch<'a>( &'a self, messages: &'a [&'a Self::Message], ) -> impl Future<Output = Vec<Result<(), Self::Error>>> + Send + 'a

where Self: Sync, Self::Error: Send,

Send multiple messages concurrently, fanning them out with futures::future::join_all.

Returns one Result per message in the same order as the input slice. A failure for one message does not abort the others.

Example

let results = sender.send_batch(&[&msg_a, &msg_b, &msg_c]).await;
for result in results {
    result?;
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors