Struct HistoricalRun 

pub struct HistoricalRun {

    pub id: i32,
    pub service_id: i32,
    pub corpus_id: i32,
    pub total: i32,
    pub invalid: i32,
    pub fatal: i32,
    pub error: i32,
    pub warning: i32,
    pub no_problem: i32,
    pub in_progress: i32,
    pub start_time: NaiveDateTime,
    pub end_time: Option<NaiveDateTime>,
    pub owner: String,
    pub description: String,
    pub public_id: Uuid,
}

Historical (Corpus, Service) run records

Fields

id: i32

id of the historical run

service_id: i32

id of the service owning this task

corpus_id: i32

id of the corpus hosting this task

total: i32

total tasks in run

invalid: i32

invalid tasks in run

fatal: i32

fatal results in run

error: i32

error results in run

warning: i32

warning results in run

no_problem: i32

results with no notable problems in run

in_progress: i32

tasks still in progress at end of run

start_time: NaiveDateTime

start timestamp of run

end_time: Option<NaiveDateTime>

end timestamp of run, i.e. timestamp of next run initiation

owner: String

owner who initiated the run

description: String

description of the purpose of this run

public_id: Uuid

Stable external handle (UUIDv7, DB-generated) for referencing this specific run independently of its (corpus, service, start_time) coordinates. Immutable once assigned (Arm 3 / D8).

Implementations

impl HistoricalRun

pub fn find_by( corpus: &Corpus, service: &Service, connection: &mut PgConnection, ) -> Result<Vec<HistoricalRun>, Error>

Obtain all historical runs for a given (Corpus, Service) pair

pub fn recent_all( connection: &mut PgConnection, limit: i64, ) -> Result<Vec<HistoricalRun>, Error>

The most recent historical runs across all corpora/services, newest first — the system-wide run-management overview. Capped at limit.

pub fn recent_filtered( connection: &mut PgConnection, corpus: Option<i32>, service: Option<i32>, owner: Option<&str>, limit: i64, ) -> Result<Vec<HistoricalRun>, Error>

The most recent historical runs, newest first, optionally narrowed to a corpus_id, service_id, and/or exact owner — the filter-driven run-management overview. Capped at limit. Any combination of filters may be None (no constraint on that field).

pub fn find_current( corpus: &Corpus, service: &Service, connection: &mut PgConnection, ) -> Result<Option<HistoricalRun>, Error>

Obtain a currently ongoing run entry for a (Corpus, Service) pair, if any

pub fn mark_completed( &self, connection: &mut PgConnection, ) -> Result<bool, Error>

Mark this historical run as completed: freeze its live tallies and set end_time, as an atomic compare-and-set (WHERE id = ? AND end_time IS NULL). Exactly one caller can ever close a given run — even under duplicate finalize passes (a re-tried last task that lands twice) or, hypothetically, concurrent writers — because the open-row predicate lives in the UPDATE itself, not in a separate read. Returns true iff this call performed the close (the UPDATE matched the still-open row); false if the run was already closed (a no-op). That true is the safe edge to hang any run-completion side effect on: it can never double-fire.

pub fn complete_if_drained( corpus: i32, service: i32, connection: &mut PgConnection, ) -> Result<bool, Error>

Run-completion-on-drain. Close the open historical run for a (corpus, service) pair the moment its work is exhausted — every task has reached a terminal severity, with nothing left TODO, in-flight (Queued), or Blocked on a prerequisite. Freezes the run’s tallies and sets end_time (via Self::mark_completed), so a finished run stops reading as “ongoing” immediately, instead of only when the next rerun supersedes it (the lazy mark_new_run path that left a run “ongoing” until the very minute the next run started). Returns true iff a run was actually closed.

Idempotent and safe to call repeatedly from the dispatcher’s finalize loop: a no-op when work still remains, when there is no open run (already closed, or never started), or for the bookkeeping services init (1) / import (2) — those are not user-facing conversion runs and are skipped.

pub fn with_live_tallies(self, connection: &mut PgConnection) -> HistoricalRun

Returns this run with its per-severity tallies reflecting live task state when the run is still open (end_time is None). A run only freezes its tallies at Self::mark_completed (i.e. when the next run supersedes it), so an open run’s stored tallies are all zero; overlaying the current progress makes the in-progress run show its real state across the run-management surfaces — the “live + historical run state” north star — instead of a misleading row of zeros (most visible on the current run and the dashboard’s “last run”). A completed run is returned unchanged: its frozen snapshot is authoritative and this is a no-op (no extra query). Cost is one grouped progress_report per open run only.

pub fn overlay_live_tallies( runs: Vec<HistoricalRun>, connection: &mut PgConnection, ) -> Vec<HistoricalRun>

Overlays live tallies onto every open run in runs using a single batched query, replacing the per-open-run with_live_tallies N+1 that made the system-wide run overview cost one progress_report per open run (O(open runs) — a real drag when many corpora convert at once). Completed runs keep their frozen tallies untouched. Use this for any multi-(corpus, service) run list; a single-pair list (≤1 open run) can keep with_live_tallies.

Trait Implementations

impl<__FK> BelongsTo<&Corpus> for HistoricalRun

where __FK: Hash + Eq, for<'__a> &'__a i32: Into<Option<&'__a __FK>>, for<'__a> &'__a Corpus: Identifiable<Id = &'__a __FK>,

type ForeignKey = __FK

The foreign key of this struct

type ForeignKeyColumn = corpus_id

The database column representing the foreign key of the table this struct represents

fn foreign_key(&self) -> Option<&Self::ForeignKey>

Returns the foreign key for self

fn foreign_key_column() -> Self::ForeignKeyColumn

Returns the foreign key column of this struct’s table

impl<__FK> BelongsTo<&Service> for HistoricalRun

where __FK: Hash + Eq, for<'__a> &'__a i32: Into<Option<&'__a __FK>>, for<'__a> &'__a Service: Identifiable<Id = &'__a __FK>,

type ForeignKey = __FK

The foreign key of this struct

type ForeignKeyColumn = service_id

The database column representing the foreign key of the table this struct represents

fn foreign_key(&self) -> Option<&Self::ForeignKey>

Returns the foreign key for self

fn foreign_key_column() -> Self::ForeignKeyColumn

Returns the foreign key column of this struct’s table

impl<__FK> BelongsTo<Corpus> for HistoricalRun

where __FK: Hash + Eq, for<'__a> &'__a i32: Into<Option<&'__a __FK>>, for<'__a> &'__a Corpus: Identifiable<Id = &'__a __FK>,

type ForeignKey = __FK

The foreign key of this struct

type ForeignKeyColumn = corpus_id

The database column representing the foreign key of the table this struct represents

fn foreign_key(&self) -> Option<&Self::ForeignKey>

Returns the foreign key for self

fn foreign_key_column() -> Self::ForeignKeyColumn

Returns the foreign key column of this struct’s table

impl<__FK> BelongsTo<Service> for HistoricalRun

where __FK: Hash + Eq, for<'__a> &'__a i32: Into<Option<&'__a __FK>>, for<'__a> &'__a Service: Identifiable<Id = &'__a __FK>,

type ForeignKey = __FK

The foreign key of this struct

type ForeignKeyColumn = service_id

The database column representing the foreign key of the table this struct represents

fn foreign_key(&self) -> Option<&Self::ForeignKey>

Returns the foreign key for self

fn foreign_key_column() -> Self::ForeignKeyColumn

Returns the foreign key column of this struct’s table

impl Clone for HistoricalRun

fn clone(&self) -> HistoricalRun

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HistoricalRun

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

Formats the value using the given formatter.

impl Eq for HistoricalRun

impl From<HistoricalRun> for RunDto

fn from(run: HistoricalRun) -> RunDto

Converts to this type from the input type.

impl From<HistoricalRun> for RunMetadata

fn from(run: HistoricalRun) -> RunMetadata

Converts to this type from the input type.

impl HasTable for HistoricalRun

type Table = table

The table this type is associated with.

fn table() -> <Self as HasTable>::Table

Returns the table this type is associated with.

impl<'ident> Identifiable for &'ident HistoricalRun

type Id = &'ident i32

The type of this struct’s identifier.

fn id(self) -> <Self as Identifiable>::Id

Returns the identifier for this record.

impl PartialEq for HistoricalRun

fn eq(&self, other: &HistoricalRun) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<__DB: Backend, __ST0, __ST1, __ST2, __ST3, __ST4, __ST5, __ST6, __ST7, __ST8, __ST9, __ST10, __ST11, __ST12, __ST13, __ST14> Queryable<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5, __ST6, __ST7, __ST8, __ST9, __ST10, __ST11, __ST12, __ST13, __ST14), __DB> for HistoricalRun

where (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, NaiveDateTime, Option<NaiveDateTime>, String, String, Uuid): FromStaticSqlRow<(__ST0, __ST1, __ST2, __ST3, __ST4, __ST5, __ST6, __ST7, __ST8, __ST9, __ST10, __ST11, __ST12, __ST13, __ST14), __DB>,

type Row = (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, NaiveDateTime, Option<NaiveDateTime>, String, String, Uuid)

The Rust type you’d like to map from.

fn build( row: (i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, NaiveDateTime, Option<NaiveDateTime>, String, String, Uuid), ) -> Result<Self>

Construct an instance of this type

impl<__DB: Backend> QueryableByName<__DB> for HistoricalRun

where i32: FromSql<SqlTypeOf<id>, __DB> + FromSql<SqlTypeOf<service_id>, __DB> + FromSql<SqlTypeOf<corpus_id>, __DB> + FromSql<SqlTypeOf<total>, __DB> + FromSql<SqlTypeOf<invalid>, __DB> + FromSql<SqlTypeOf<fatal>, __DB> + FromSql<SqlTypeOf<error>, __DB> + FromSql<SqlTypeOf<warning>, __DB> + FromSql<SqlTypeOf<no_problem>, __DB> + FromSql<SqlTypeOf<in_progress>, __DB>, NaiveDateTime: FromSql<SqlTypeOf<start_time>, __DB>, Option<NaiveDateTime>: FromSql<SqlTypeOf<end_time>, __DB>, String: FromSql<SqlTypeOf<owner>, __DB> + FromSql<SqlTypeOf<description>, __DB>, Uuid: FromSql<SqlTypeOf<public_id>, __DB>,

fn build<'__a>(row: &impl NamedRow<'__a, __DB>) -> Result<Self>

Construct an instance of Self from the database row

impl StructuralPartialEq for HistoricalRun