Struct NotifyJob 

pub struct NotifyJob(/* private fields */);

Delivers queued notifications.

Holds the whole profile name -> dispatcher map rather than one dispatcher, because there is exactly one handler for a kind and a job row names its own profile. That is also why nothing deduplicates it at registration the way the signer handlers are deduplicated: there is only ever one of these.

The map arrives as a Notifiers handle rather than a plain Arc because this handler is registered once per generation but must see the current configuration: a row queued by a reloaded router names a slot id only the new map has, and an unknown one is retired rather than retried.

Implementations

impl NotifyJob

pub fn new(dispatchers: impl Into<Notifiers>) -> Self

Trait Implementations

impl JobHandler for NotifyJob

fn run<'life0, 'life1, 'async_trait>( &'life0 self, job: &'life1 Job, ) -> Pin<Box<dyn Future<Output = JobOutcome> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

One delivery attempt.

Three things retire the job immediately rather than retrying, and they share a shape: nothing about them can change between now and the fifth attempt. A payload that does not parse never will; a profile or a backend that is no longer configured is a configuration the operator changed under a queued row, and re-reading it every thirty seconds until the budget runs out would say nothing the first log line did not.

fn abandon<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, job: &'life1 Job, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

The end of the line for one notification.

There is nobody to tell, which is the whole difference from RelayJob::abandon: a relay’s subject is a client polling an order, and this one’s subject is the operator whose only channel is what just failed. So this is a log line and nothing else — but it is the log line to alert on, because it is the moment a notification is genuinely lost.

fn kind(&self) -> &'static str

The jobs.kind this handler answers for. One handler per kind — the registry refuses a second, since two would each get half the rows.

fn lease(&self, _job: &Job) -> Option<Duration>

How long one attempt at this row may take, and therefore how long the lease is held.

fn recover<'life0, 'life1, 'async_trait>( &'life0 self, _queue: &'life1 JobQueue, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Re-derives work a previous process left unfinished. Run once, at startup, before the loop begins.