tag2upload_service_manager/

ui_routes.rs

use crate::prelude::*;
use crate::ui_render::*;

fn status_is_queued() -> impl Bsql {
    bsql!("    status IN " [
                              JobStatus::Noticed,
                              JobStatus::Queued,
                              JobStatus::Building,
                            ] "")
}

fn show_recent_threshold(gl: &Arc<Globals>) -> TimeT {
    let now = gl.now_systemtime();

    now
        .checked_sub(*gl.config.intervals.show_recent)
        .unwrap_or(now /* whatever */)
        .into()
}

struct FromInterestingJobs<Q: Bsql, A: Bsql> {
    queued_unrecent: Q,
    anystatus_recent: A,
}

impl<'t> FromInterestingJobs<bsql::EmptyFragment, bsql::EmptyFragment> {
    fn new<'s>(recent: &'s TimeT) -> FromInterestingJobs<
        impl Bsql + 's,
        impl Bsql + 's,
    > {
        FromInterestingJobs {
            queued_unrecent: bsql!("
                      FROM jobs
                     WHERE " {status_is_queued()} "
                       AND last_update < " recent "
                "),
            anystatus_recent: bsql!("
                      FROM jobs
                     WHERE last_update >= " recent "
                "),
        }
    }
}

//---------- / ----------

#[rocket::get("/")]
pub async fn r_toplevel(req_info: UiReqInfoUnchecked) -> RenderedTemplate {
    let req_info = req_info.check()?;

    let gl = globals();

    #[derive(Deftly, Ord, PartialOrd, Eq, PartialEq)]
    #[derive_deftly(FromSqlRow)]
    struct JobStatusCount {
        status: JobStatus,
        duplicate_of: Option<JobId>,
        count: i64,
    }

    #[derive(Deftly, Ord, PartialOrd, Eq, PartialEq)]
    #[derive_deftly(UiMap)]
    struct ShownJobStatusCounts {
        status: ShownJobStatus,
        #[deftly(ui(flatten))]
        values: ShownJobStatusCountsValues,
    }
    #[derive(Deftly, Ord, PartialOrd, Eq, PartialEq, Default)]
    #[derive_deftly(UiMap)]
    struct ShownJobStatusCountsValues {
        recent: i64,
        unarchived: i64,
        total: i64,
    }

    // Ideally we would list counts of *all* jobs, but sqlite can't maintain
    // an "index" giving count(*), and we don't want to do a full table scan.
    let recent = show_recent_threshold(&gl);
    let from_jobs = FromInterestingJobs::new(&recent);

    let (status_count, pause, last_archive) =
        db_transaction(TN::Readonly, |dbt| {

            let mut counts = ShownJobStatus::iter()
                .map(|s| (s, ShownJobStatusCountsValues::default()))
                .collect::<HashMap<_, _>>();

            let mut add = |JobStatusCount { status, duplicate_of, count }| {
                let shown = ShownJobStatus::new(status, duplicate_of);
                counts.entry(shown).or_default().recent += count;
                Ok::<_, IE>(())
            };

            // Even this way it's a bit tiresome.
            // sqlite won't optimise this the way we want,
            // unless we do it as two queries, - one of which scans
            // the whole queue.  Fine.

            dbt.bsql_query_n_call(
                &bsql!("
                    SELECT status, duplicate_of, count(1) AS count
                         " {&from_jobs.queued_unrecent} "
                  GROUP BY status, duplicate_of
                "),
                &mut add,
            )?;

            dbt.bsql_query_n_call(
                &bsql!("
                    SELECT status, duplicate_of, 1 as count
                         " {&from_jobs.anystatus_recent} "
                "),
                &mut add,
            )?;

            let pause = query_pause_insn_either(dbt)?;

            let mut update_from_stats = |table: &dyn Bsql, upd: fn(&mut _, _)| {
                dbt.bsql_query_n_call(
                    &bsql!("SELECT * FROM " {table} ""),
                    &mut |StatsByShownStatusRow { shown_status, n_jobs }| {
                        upd(
                            counts.entry(shown_status).or_default(),
                            n_jobs
                        );
                        Ok::<_, IE>(())
                    }
                )
            };

            update_from_stats(
                &bsql!("stats_by_shown_status"),
                |ent: &mut _, n_jobs| {
                    ent.unarchived += n_jobs;
                    ent.total += n_jobs;
                },
            )?;
            update_from_stats(
                &bsql!("stats_by_shown_status_expired"),
                |ent: &mut _, n_jobs| {
                    ent.total += n_jobs;
                },
            )?;

            let mut counts = counts.into_iter()
                .map(|(status, values)| {
                    ShownJobStatusCounts { status, values }
                })
                .collect_vec();

            counts.sort();

            let last_archive = LastExpiryRow::for_ui(dbt)?;

            Ok((counts, pause, last_archive))
        })?;

    let status_count = UiSerializeRows(status_count);

    #[derive(Debug, Copy, Clone, Serialize)]
    #[serde(rename_all = "snake_case")]
    enum ManagerStatus {
        Running,
        Paused,
        Throttled,
        #[serde(rename = "shutting down")]
        ShuttingDown,
        Crashing,
    }
    use ManagerStatus as MS;

    let manager_status = match (&gl.state.borrow().shutdown_reason, &pause) {
        (None, None) => MS::Running,
        (None, Some((_insn, None))) => MS::Paused,
        (None, Some((_insn, Some(IsThrottled)))) => MS::Throttled,
        (Some(Ok(ShuttingDown {})),_) => MS::ShuttingDown,
        (Some(Err(_)),_) => MS::Crashing,
    };

    let workers = {
        let w = gl.worker_tracker.list_workers();
        UiSerializeRows(w)
    };

    let mut n_workers_idle = 0;
    let mut n_workers_busy = 0;
    for w in &workers.0 {
        use WorkerPhase as WP;
        match w.phase {
            WP::Building | WP::Selected => n_workers_busy += 1,
            WP::Idle => n_workers_idle += 1,
            WP::Init | // doesn't count as connected
            WP::Disconnected => {}
        }
    }

    #[derive(Debug, Copy, Clone, Serialize)]
    #[serde(rename_all = "snake_case")]
    enum OverallStatus {
        Down,
        Maintenance,
        #[serde(rename = "(re)starting")]
        Starting,
        Busy,
        Up,
    }
    use OverallStatus as OS;

    let no_workers = || n_workers_idle + n_workers_busy == 0;
    let just_started = || {
        let now = gl.now_systemtime();
        now.duration_since(
            *gl.last_worker_restart.read().expect("poisoned")
        ).unwrap_or_default()
            < *gl.config.timeouts.disconnected_worker_expire
    };
    let manager_overall_status = || match manager_status {
        MS::Running => None,
        MS::Crashing => Some(OS::Down),
        MS::Paused | MS::Throttled | MS::ShuttingDown => Some(OS::Maintenance),
    };

    let overall_status =
        if no_workers() && !just_started() { OS::Down }
        else if let Some(from_ms) = manager_overall_status() { from_ms }
        else if no_workers() { OS::Starting }
        else if n_workers_idle == 0 { OS::Busy }
        else { OS::Up };

    let recent = HtTimeT(recent);

    template_page! {
        "toplevel.html", req_info;
        {
            overall_status,
            manager_status,
            pause_info: pause.map(|(insn, _thro)| insn.pause_info),
            status_count,
            recent,
            last_archive,
            workers,
            n_workers_busy,
            n_workers_idle,
            n_workers_up: n_workers_busy + n_workers_idle,
        }
    }
}

//---------- /queue ----------

#[rocket::get("/queue")]
pub async fn r_queue(req_info: UiReqInfoUnchecked) -> RenderedTemplate {
    let req_info = req_info.check()?;

    let (data, ()) = db_jobs_for_ui(
        req_info.vhost,
        &status_is_queued(),
        &bsql!(" jid ASC "),
        |_dbt| Ok(()),
    )?;

    template_page! {
        "queue.html", req_info;
        {
            jobs: data,
        }
    }
}

//---------- /recent ----------

#[rocket::get("/recent")]
pub async fn r_recent(req_info: UiReqInfoUnchecked) -> RenderedTemplate {
    let req_info = req_info.check()?;
    let gl = globals();
    let recent = show_recent_threshold(&gl);
    let from_jobs = FromInterestingJobs::new(&recent);

    let (jobs, last_archive) = db_rows_for_ui::<JobForUi, _>(
            req_info.vhost,
            &bsql!("
                          SELECT " {job_for_ui_cols(&bsql!("jobs"))} "
                         " {from_jobs.queued_unrecent} "
                          UNION
                          SELECT " {job_for_ui_cols(&bsql!("jobs"))} "
                         " {from_jobs.anystatus_recent} "
                        ORDER BY last_update DESC
            "),
            |dbt| LastExpiryRow::for_ui(dbt),
        )?;

    let recent = HtTimeT(recent);
    let jobs = UiSerializeRows(jobs);

    template_page! {
        "recent.html", req_info;
        {
            jobs,
            recent,
            last_archive,
        }
    }
}

//---------- /all-jobs ----------

#[rocket::get("/all-jobs")]
pub async fn r_all_jobs(req_info: UiReqInfoUnchecked) -> RenderedTemplate {
    let req_info = req_info.check()?;

    // TODO this query loads the whole db into memory
    // This is OK if there aren't too many.  If this becomes a problem
    // we should;
    //   - use watersheds to coalesce multiple queries for this route
    //   - do the db query and stream rendering rows to a temporary file
    //   - stream the temporary file out with pread
    let (data, last_archive) = db_jobs_for_ui(
        req_info.vhost,
        &bsql!(" TRUE "),
        &bsql!(" last_update DESC "),
        |dbt| LastExpiryRow::for_ui(dbt),
    )?;

    template_page! {
        "all-jobs.html", req_info;
        {
            jobs: data,
            last_archive,
        }
    }
}

//---------- /job/JID ----------

#[rocket::get("/job/<jid_u64>")]
pub async fn r_job(jid_u64: u64, req_info: UiReqInfoUnchecked)
                   -> RenderedTemplate
{
    let req_info = req_info.check()?;

    let data = db_query_for_ui(req_info.vhost, |dbt| {
        let j = dbt.bsql_query_01::<JobForUi>(&bsql!("
                SELECT " {job_for_ui_cols(&bsql!("jobs"))}
                " FROM jobs WHERE jid = " jid_u64 "
            "))?;
        let Some(j) = j else {
            return Ok(Err(WebError::PageNotFoundHere(
                anyhow!("job {jid_u64} does not exist or has been archived")
            )));
        };
        // The `job_history` table has au superset of the columns in JobState
        //
        // We don't currently linkify duplicate jobs in the history display,
        // only in the main tables of jobs.  So we don't need job_for_ui_cols.
        let mut history: Vec<JobState> = dbt.bsql_query_n_vec(&bsql!("
                SELECT *
                         FROM job_history
                        WHERE jid = " jid_u64 "
                     ORDER BY histent ASC
           "))?;
        let tag_object = match j.s.status {
            JobStatus::Noticed |
            JobStatus::NotForUs => String::new(),
            JobStatus::Queued |
            JobStatus::Building |
            JobStatus::Failed |
            JobStatus::Irrecoverable |
            JobStatus::Uploaded => j.tag_data
                .as_deref().cloned().unwrap_or_default(),
        };
        history.push(j.s.clone());

        // Replace identical info lines with ditto marks.
        //   https://en.wikipedia.org/wiki/Ditto_mark
        // This is helpful because they can be very long, so when
        // they wrap you just see a bunch of text that's hard to compare.
        let mut last_info = None;
        for histent in &mut history {
            let this_info = &mut histent.info;
            if Some(&this_info) == last_info.as_ref() {
                *this_info = r#" "  " "#.into();
            } else {
                last_info = Some(this_info);
            }
        }

        Ok(Ok((UiSerializeMap(j), UiSerializeRows(history), tag_object)))
    })?;

    let (j, history, tag_object) = data?;
    template_page! {
        "job.html", req_info;
        {
            j,
            history,
            tag_object,
        }
    }
}

//---------- error catcher ----------

fn handle_error(
    status: rocket::http::Status,
    client_ip: Option<IpAddr>,
    request_path: Option<PathBuf>,
) -> (ContentType, String) {
    let request_path = request_path.map(
        |maybe_relative| PathBuf::from("/").join(maybe_relative)
    );

    debug!(
        "from {}: error {}: path={}",
        client_ip
            .map(|y| y.to_string())
            .unwrap_or_else(|| format!("<unknown>")),
        status.code,
        request_path
            .map(|y| format!("{y:?}"))
            .unwrap_or_else(|| format!("<invalid>")),
    );
    (|| {
        let s = template_html_unchecked! {
            "error.html",
            tera_context! {
                t2usm_version: &globals().version_info,
                status_headline: status.to_string(),
            }
        };
        Ok::<_, WebError>((ContentType::HTML, s?))
    })().unwrap_or_else(|e| {
        (ContentType::Text, format!("error rendering error: {e}"))
    })
}

// If we don't install an error catcher, Rocket logs like this
//    2025-06-30T17:05:42.542766Z  WARN rocket::server::_: No ESC[1;34m404ESC[0m catcher registered. Using Rocket default.    
//
// We don't much like the default error document, either.
//
// And the default handler logs with colour escapes.
#[rocket::catch(default)]
fn default_error_catcher(
    status: rocket::http::Status,
    req: &rocket::Request,
) -> (ContentType, String) {
    handle_error(
        status,
        req.client_ip(),
        req.segments::<PathBuf>(0..).ok(), // discard errors
    )
}

// This exists because if Rocket doesn't find a route, it logs twice,
// at level ERROR and WARN.  But 404s are normal, as attacks wash up.
//
//     https://github.com/rwf2/Rocket/issues/2951
#[rocket::get("/<any..>")]
fn wildcard_404(
    client_ip: Option<IpAddr>,
    any: Option<PathBuf>,
) -> (rocket::http::Status, (ContentType, String))
{
    let status = rocket::http::Status::NotFound;
    (status, handle_error(status, client_ip, any))
}

//---------- inventories ----------

load_template_parts! {
    "duplicate-of.part.html",
    "jobtable.part.html",
    "footer.part.html",
    "navbar.part.html",
    "recent-note.part.html",
    "retry-earliest.part.html",
    "archived-note.part.html",
}

pub(crate) const NAVBAR: &[NavbarEntry] = &[
    ("service",     "toplevel.html",     "/"),
    ("queue",       "queue.html",        "/queue"),
    ("recent",      "recent.html",       "/recent"),
    ("all jobs",    "all-jobs.html",     "/all-jobs"),
];

pub fn mount_ui_catchers(rocket: RocketBuild) -> RocketBuild {
    let wildcards = {
        // Set up a separate 404 handler for each HTTP method.
        //
        // Rocket doesn't have method wildcard routes,
        // https://github.com/rwf2/Rocket/issues/2731

        use rocket::http::Method::*;

        let mut w = rocket::routes![wildcard_404];
        for method in [/* Get, already included */
                       Put, Post, Delete, Options,
                       Head, Trace, Connect, Patch] {
            w.push({
                let mut route = w[0].clone();
                route.method = method;
                route
            })
        }
        w
    };

    rocket.mount("/", rocket::routes![
        r_toplevel,
        r_queue,
        r_recent,
        r_all_jobs,
        r_job,
    ])
        .mount("/", wildcards)
        .register("/", rocket::catchers![default_error_catcher])
}