Struct Backend 

pub struct Backend {
    pub connection: PgConnection,
}

Provides an interface to the Postgres task store

Fields

connection: PgConnection

The Diesel PgConnection object

Implementations

impl Backend

Instance methods

pub fn mark_imported( &mut self, imported_tasks: &[NewTask], ) -> Result<usize, Error>

Insert a vector of new NewTask tasks into the Task store For example, on import, or when a new service is activated on a corpus

pub fn mark_done(&mut self, reports: &[TaskReport]) -> Result<(), Error>

Insert a vector of TaskReport reports into the Task store, also marking their tasks as completed with the correct status code.

pub fn mark_rerun(&mut self, options: RerunOptions<'_>) -> Result<(), Error>

Given a complex selector, of a Corpus, Service, and the optional severity, category and what mark all matching tasks to be rerun

pub fn pause_run( &mut self, corpus_id: i32, service_id: i32, ) -> Result<usize, Error>

Pause a (corpus, service) run: block every in-progress task (status >= 0) so the dispatcher stops leasing them. Returns the number paused. The CLI/agent twin of the report screen’s “Pause run”. Reversible with Backend::resume_run.

pub fn resume_run( &mut self, corpus_id: i32, service_id: i32, ) -> Result<usize, Error>

Resume a paused (corpus, service) run: return every Blocked task (status < -5) to TODO so the dispatcher picks them up. Returns the number resumed. The inverse of Backend::pause_run.

pub fn mark_new_run( &mut self, corpus: &Corpus, service: &Service, owner: String, description: String, ) -> Result<(), Error>

While not changing any status information for Tasks, add a new historical run bookmark

pub fn save_historical_tasks( &mut self, corpus: &Corpus, service: &Service, ) -> Result<usize, Error>

Save the current historical tasks for reference

pub fn delete<Model: CortexDeletable>( &mut self, object: &Model, ) -> Result<usize, Error>

Generic delete method, uses primary “id” field

pub fn delete_by<Model: CortexDeletable>( &mut self, object: &Model, field: &str, ) -> Result<usize, Error>

Delete all entries matching the “field” value of a given object

pub fn add<Model: CortexInsertable>( &mut self, object: &Model, ) -> Result<usize, Error>

Generic addition method, attempting to insert in the DB a Task store datum applicable for any struct implementing the CortexORM trait (for example Corpus, Service, Task)

pub fn fetch_tasks( &mut self, service: &Service, limit: usize, ) -> Result<Vec<Task>, Error>

Fetches no more than limit queued tasks for a given Service

pub fn clear_limbo_tasks(&mut self) -> Result<usize, Error>

Globally resets any “in progress” tasks back to “queued”. Particularly useful for dispatcher restarts, when all “in progress” tasks need to be invalidated

pub fn clear_limbo_tasks_except( &mut self, in_flight: &[i64], ) -> Result<usize, Error>

Like Self::clear_limbo_tasks, but preserves the given in-flight task ids (the live progress_queue on a ventilator restart) so tasks a worker is actively processing are not reset to TODO and double-dispatched. See tasks_aggregate::clear_limbo_tasks_except.

pub fn register_service( &mut self, service: &Service, corpus: &Corpus, owner: String, description: String, ) -> Result<(), Error>

Activates an existing service on the given corpus. if the service has previously been registered, this call will RESET the service into a mint state also removing any related log messages. The new run is attributed to owner with description (the UI/API thread the actor; the CLI passes a default). Takes the resolved Corpus (not a path): a sandbox shares its parent’s path, so a path lookup would hit the parent.

pub fn extend_service( &mut self, service: &Service, corpus: &Corpus, ) -> Result<(), Error>

Extends an existing service on the given corpus. if the service has previously been registered, this call will ignore existing entries and simply add newly encountered ones. Takes the resolved Corpus (not a path) for the same sandbox-shares-parent-path reason as register_service.

pub fn destroy_service_by_name(&mut self, name: &str) -> Result<usize, Error>

Permanently destroys a service by name — its definition plus all of its tasks + log_* rows across every corpus, in one transaction (orphan-free + crash-consistent; closes R-6). Refuses the magic init/import services. See [services_aggregate::destroy_service_by_name].

pub fn corpora(&mut self) -> Vec<Corpus>

Returns a vector of currently available corpora in the Task store

pub fn tasks( &mut self, corpus: &Corpus, service: &Service, task_status: &TaskStatus, ) -> Vec<Task>

Returns a vector of tasks for a given Corpus, Service and status

pub fn entries( &mut self, corpus: &Corpus, service: &Service, task_status: &TaskStatus, ) -> Vec<String>

Returns a vector of task entry paths for a given Corpus, Service and status

pub fn task_report( &mut self, options: TaskReportOptions<'_>, ) -> Vec<HashMap<String, String>>

Given a complex selector, of a Corpus, Service, and the optional severity, category and what, Provide a progress report at the chosen granularity

pub fn progress_report( &mut self, corpus: &Corpus, service: &Service, ) -> HashMap<String, f64>

Provides a progress report, grouped by severity, for a given Corpus and Service pair

pub fn refresh_report_summary(&mut self) -> Result<(), Error>

Recomputes the report_summary rollup (Arm 14 #6); call on the run-completion path so the cheap category/what report reads stay fresh.

pub fn invalidate_report_cache( &mut self, corpus_id: i32, service_id: i32, ) -> Result<(), Error>

Drop the cached report grains for one (corpus, service) scope so the next report view repopulates from current data. Called per touched scope on the run-completion path — scoped, a cheap keyed DELETE, never the global all-corpora scan that used to stall conversions.

pub fn complete_run_if_drained( &mut self, corpus_id: i32, service_id: i32, ) -> Result<bool, Error>

Run-completion-on-drain: close the (corpus, service) pair’s open historical run iff its work is exhausted (every task terminal). Delegates to HistoricalRun::complete_if_drained; returns true iff a run was closed. Called per touched scope from the dispatcher’s finalize loop when the queue idles, so a finished run is closed at once rather than at the next rerun.

pub fn category_rollup( &mut self, corpus: &Corpus, service: &Service, severity: &str, limit: i64, offset: i64, ) -> Vec<ReportSummaryRow>

Category-grain report for (corpus, service, severity), read from the report_summary rollup, windowed to [offset, offset + limit) (ordered by descending task count).

pub fn what_rollup( &mut self, corpus: &Corpus, service: &Service, severity: &str, category: &str, limit: i64, offset: i64, ) -> Vec<ReportSummaryRow>

what-grain drill-down for (corpus, service, severity, category), read from the rollup, windowed to [offset, offset + limit) (ordered by descending task count).

pub fn severity_totals( &mut self, corpus: &Corpus, service: &Service, severity: &str, ) -> (i64, i64)

The per-severity grand totals (distinct tasks, total messages) for (corpus, service, severity), read from the rollup — the denominators the category-grain report shows. (0, 0) when the severity has no logged messages.

pub fn category_totals( &mut self, corpus: &Corpus, service: &Service, severity: &str, category: &str, ) -> (i64, i64)

The category-grain totals (distinct tasks, total messages) for (corpus, service, severity, category) — the denominators the what drill-down shows. (0, 0) when the category is empty.

Trait Implementations

impl Debug for Backend

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Backend

fn default() -> Self

Returns the “default value” for a type.