Struct ChallengeValidateJob 

pub struct ChallengeValidateJob { /* private fields */ }

Performs a claimed challenge validation and records its answer.

Implementations

impl ChallengeValidateJob

pub fn new( database: Arc<Database>, audit: Arc<Auditor>, profiles: Vec<(String, Arc<Profile>)>, ) -> Self

profiles is this generation’s profile per name.

Trait Implementations

impl JobHandler for ChallengeValidateJob

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 attempt at the outbound check.

A validation that ran is terminal, whichever way it went. A refused challenge is the challenge’s answer — recorded by run_validation in one transaction with its authorization and order, exactly as it was when this ran inside the request — so the job is Done. JobOutcome::Retry is reserved for the attempt never having happened: a database that would not answer, or a profile this process does not mount. That keeps challenge_failed meaning what it has always meant, and keeps a client’s order reaching invalid as promptly as it used to.

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

One attempt may take a whole challenge.timeout_ms.

Which profile’s is not knowable here — the row names a challenge, and walking it up to its order is a database read this synchronous hook cannot make — so the budget is the widest any mounted profile allows. Erring long costs only a longer wait before another runner may reclaim a stranded row; erring short would let two runners probe one client’s host at once, which is the thing the claim exists to prevent.

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 attempts ran out, or the authorization expired under it.

A challenge left processing would be polled by its client until the authorization expired, saying nothing. Record the failure instead, so the order goes invalid and the client stops — RelayJob::abandon’s rule, which marks its order invalid for the same reason.

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-queues a claim a previous process took and never settled.

The window is small but real: post_challenge claims the challenge and then enqueues, so a crash between the two leaves a row processing with no job. Without this it would stay that way until its authorization expired — the trade claim_for_validation documents, and the one this closes now that something outlives the request.

Safely repeatable: the identity index refuses a duplicate, so a challenge whose job is still live is simply not re-queued.

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.