Admin › Backups: whether each owner's backup ran, and who has none 1e8a6e8bb91b

{% extends "base.html" %}

{% block title %}Backups · Administration{% endblock %}

{% block mainclass %} class="wide"{% endblock %}

{% block content %}

<div class="head"><h1>Backups <small>{{ owners.len()|plural("owner", "owners") }} · <a href="/admin">Administration</a></small></h1></div>

<p class="small mute">Each user and organisation backs up its own repositories, to a place it controls (docs/backups.md). Here is whether each one ran and how it went; what a run wrote stays with its owner. This site's own backup runs on its host, outside the hub.</p>

<section class="card-box">

  <div class="card-head"><h2>Owners' backups</h2><span class="count-chip">{{ owners.len() }}</span></div>

  {% if owners.is_empty() %}<p class="empty small">Nobody has set up a backup yet.</p>

  {% else %}

  <div class="table"><table class="backup-runs">

    <tr><th>Owner</th><th>How often</th><th>Where</th><th>Kept</th><th>Repositories</th><th>Last run</th><th>Failed today</th></tr>

    {% for o in owners %}

    <tr>

      <td><a href="/{{ o.setting.owner }}">{{ o.setting.owner }}</a> <span class="mute small">{% if o.setting.kind == "org" %}organisation{% else %}user{% endif %}</span></td>

      <td>{% if o.setting.every == "off" %}<span class="mute">off</span>{% else %}{{ o.setting.every }}{% endif %}</td>

      <td><code>{{ o.place() }}</code></td>

      <td>{{ o.setting.keep_days }} days</td>

      <td>{{ o.repos }}</td>

      <td>{% if let Some(r) = o.last %}<span class="backup-status st-{{ r.status }}">{{ r.status }}</span> <time title="{{ r.started_ms|when_i }}">{{ r.started_ms|ago_i }}</time> <span class="mute small">{{ r.repos }} repos, {{ (r.bytes / 1024) }} KiB sent</span>{% if !r.detail.is_empty() %}<div class="small mute">{{ r.detail }}</div>{% endif %}{% else %}<span class="mute">never</span>{% endif %}</td>

      <td>{% if o.failed_day > 0 %}<span class="backup-status st-failed">{{ o.failed_day }}</span>{% else %}<span class="mute">0</span>{% endif %}</td>

    </tr>

    {% endfor %}

  </table></div>

  {% endif %}

</section>

<section class="card-box">

  <div class="card-head"><h2>Not backed up</h2><span class="count-chip">{{ uncovered.len() }}</span></div>

  {% if uncovered.is_empty() %}<p class="empty small">Every owner of a repository backs it up.</p>

  {% else %}

  <p class="small mute">These own repositories that no backup covers: their owners set one up under Settings › Backups (an organisation's under its settings).</p>

  <ul class="plain">{% for (owner, n) in uncovered %}<li><a href="/{{ owner }}">{{ owner }}</a> <span class="mute small">{{ n|plural("repository", "repositories") }}</span></li>{% endfor %}</ul>

  {% endif %}

</section>

{% endblock %}

/// One owner's backup as Admin › Backups shows it (§5): its setting, its

/// newest run, and how many runs failed in the last day. An administrator

/// sees that it ran, never what it wrote.

#[derive(Clone, Debug, Serialize)]

pub struct Overview {

    pub setting: Setting,

    pub last: Option<Run>,

    pub failed_day: i64,

    /// The repositories it covers now.

    pub repos: i64,

}

impl Overview {

    /// Where its runs go, as a person reads it.

    pub fn place(&self) -> String {

        let s = &self.setting;

        match s.destination.as_str() {

            "gcs" if s.prefix.is_empty() => format!("gs://{}", s.target),

            "gcs" => format!("gs://{}/{}", s.target, s.prefix),

            _ => format!("{}/{}", s.target, s.owner),

        }

    }

}

/// Every owner's backup (Admin › Backups), and the owners of repositories

/// that none covers, with how many each has.

pub async fn overview(pool: &Pool) -> sqlx::Result<(Vec<Overview>, Vec<(String, i64)>)> {

    let settings: Vec<Setting> = sqlx::query_as("SELECT * FROM backup_settings ORDER BY owner").fetch_all(pool).await?;

    let counts: Vec<(String, i64)> =

        sqlx::query_as("SELECT owner, COUNT(*) FROM repositories GROUP BY owner ORDER BY owner").fetch_all(pool).await?;

    let day_ago = db::now_ms() - 86_400_000;

    let mut out = Vec::new();

    for s in settings {

        let last = runs(pool, &s.owner, 1).await?.into_iter().next();

        let failed_day: i64 =

            sqlx::query_scalar("SELECT COUNT(*) FROM backup_runs WHERE owner = ? AND status = 'failed' AND started_ms >= ?")

                .bind(&s.owner)

                .bind(day_ago)

                .fetch_one(pool)

                .await?;

        let repos = counts.iter().find(|(o, _)| *o == s.owner).map_or(0, |c| c.1);

        out.push(Overview { setting: s, last, failed_day, repos });

    }

    let uncovered =

        counts.into_iter().filter(|(owner, _)| !out.iter().any(|o| o.setting.owner == *owner && o.setting.every != "off")).collect();

    Ok((out, uncovered))

}

use crate::backups::{self, Overview, Run, Setting};

#[derive(Template)]

#[template(path = "admin_backups.html")]

pub struct AdminPage {

    shell: Shell,

    owners: Vec<Overview>,

    /// Owners of repositories no backup covers, with how many each has.

    uncovered: Vec<(String, i64)>,

}

/// Admin › Backups (docs/backups.md §5): every owner's backup, whether it

/// ran and how it went, and who has none. Administrators only.

pub async fn admin(State(app): State<Shared>, viewer: Viewer) -> Result<Page<AdminPage>, Error> {

    let shell = Shell::new(&app, "/admin/backups", &viewer);

    if !viewer.is_admin() {

        return Err(Error::not_found(shell));

    }

    let (owners, uncovered) = backups::overview(&app.db).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    Ok(Page(AdminPage { shell, owners, uncovered }))

}

        .route("/admin/backups", get(backups::admin))

    // Admin › Backups (docs/backups.md §5): whether each ran, and who has

    // none; administrators only.

    sqlx::query("UPDATE accounts SET is_admin = (username = 'andy')").execute(&app.db).await.unwrap();

    app.repos.create(&oxygenhub::repos::RepoName::parse("bob/game").unwrap(), None).unwrap();

    db::repos::create(&app.db, "bob", "game", "", hub_api::Visibility::Public).await.unwrap();

    assert_eq!(get(app, "/admin/backups", Some(&bob)).await.status, StatusCode::NOT_FOUND);

    let admin = get(app, "/admin/backups", Some(&andy)).await;

    assert_eq!(admin.status, StatusCode::OK);

    assert!(admin.body.contains("gs://andy-backup") && admin.body.contains("hourly") && admin.body.contains("never"), "{}", admin.body);

    let missing = &admin.body[admin.body.find("Not backed up").unwrap()..];

    assert!(missing.contains("href=\"/bob\"") && missing.contains("1 repository"), "{missing}");

    assert!(get(app, "/admin", Some(&andy)).await.body.contains("/admin/backups"));

release assets travel with the stores; Admin › Backups (#176). Next:

- **The site administrator:** Admin › Backups (built 2026-10-14,

  oxygenhub#176), a table of every owner's backup (how often, where, how

  long runs are kept, the repositories it covers, the last run with its

  outcome, and the runs that failed in the last day), and the owners of

  repositories no backup covers. They may not read an owner's bucket, only

  see that it ran. The site's own backup runs on its host, outside the

  hub, and the page says so.

  <a href="/admin/backups">Backups ↗</a>