runner_updates.rs 92.5%

321 of 347 lines run, 57 of 136 functions · run #474 on main · run missed

//! Admin → Runners → Updates (oxygenhub#322): where runner builds come
//! from, and who takes them: the site's, each owner's, each test group's
//! and each runner's settings, the nearest winning; test groups of chosen
//! runners or a percentage of them.

use super::settings::csrf;
use super::{filters, Error, Page, Shell};
use crate::auth::Viewer;
use crate::db::runner_updates::{self as rdb, Group, Policy};
use crate::db::{accounts, runners};
use crate::runner_updates::{self as ru, Levels};
use crate::Shared;
use askama::Template;
use axum::extract::{Form, Path, State};
use flow_core::api::UpdatePolicy;
use serde::Deserialize;

fn require_admin(viewer: &Viewer, shell: &Shell) -> Result<accounts::Account, Error> {
    match viewer.account() {
        Some(a) if a.is_admin => Ok(a.clone()),
        _ => Err(Error::not_found(shell.clone())),
    }
}

/// One level's settings as its form shows them: `inherit`, `on` or `off`
/// for the switches, blank for an inherited channel or window.
pub struct PolicyView {
    pub scope: String,
    pub key: String,
    pub label: String,
    pub updates: &'static str,
    pub channel: String,
    pub window: String,
    pub dry_run: &'static str,
}

impl PolicyView {
    fn of(p: &Policy, label: String) -> PolicyView {
        let tri = |b: Option<bool>| match b {
            Some(true) => "on",
            Some(false) => "off",
            None => "inherit",
        };
        PolicyView {
            scope: p.scope.clone(),
            key: p.key.clone(),
            label,
            updates: tri(p.updates),
            channel: p.channel.clone().unwrap_or_default(),
            window: match (p.window_from, p.window_to) {
                (Some(a), Some(b)) => format!("{a:02}-{b:02}"),
                _ => String::new(),
            },
            dry_run: tri(p.dry_run),
        }
    }

    /// The settings in words, for a table.
    pub fn summary(&self) -> String {
        let mut s = vec![];
        if self.updates != "inherit" {
            s.push(format!("updates {}", self.updates));
        }
        if !self.channel.is_empty() {
            s.push(format!("channel {}", self.channel));
        }
        if !self.window.is_empty() {
            s.push(format!("window {} UTC", self.window));
        }
        if self.dry_run != "inherit" {
            s.push(format!("dry run {}", self.dry_run));
        }
        if s.is_empty() {
            "inherits everything".into()
        } else {
            s.join(", ")
        }
    }
}

pub struct GroupView {
    pub g: Group,
    /// Whom it can hold, in words.
    pub reach: String,
    /// Its members now, by name.
    pub members: Vec<String>,
    pub chosen: Vec<i64>,
    pub policy: PolicyView,
}

pub struct RunnerView {
    pub r: runners::Runner,
    pub groups: Vec<String>,
    pub effective: UpdatePolicy,
    /// What the hub would offer it now.
    pub offer: String,
    pub policy: PolicyView,
}

impl RunnerView {
    /// Its effective settings, each with where it came from.
    pub fn effective_words(&self) -> String {
        let e = &self.effective;
        let mut s = vec![format!("updates {} ({})", if e.updates { "on" } else { "off" }, e.from[0])];
        if e.updates {
            s.push(format!("channel {} ({})", e.channel, e.from[1]));
            if let Some((a, b)) = e.window {
                s.push(format!("window {a:02}–{b:02} UTC ({})", e.from[2]));
            }
            if e.dry_run {
                s.push(format!("dry run ({})", e.from[3]));
            }
        }
        s.join(" · ")
    }
}

#[derive(Template)]
#[template(path = "admin_runner_updates.html")]
pub struct UpdatesPage {
    shell: Shell,
    repo: String,
    site: PolicyView,
    owners: Vec<PolicyView>,
    groups: Vec<GroupView>,
    runners: Vec<RunnerView>,
    /// Builds held back after rolling back on a runner (#326).
    holds: Vec<rdb::Hold>,
    notice: Option<String>,
    error: Option<String>,
}

/// Who changes runner updates: the site's administrators anything; an
/// organisation's owners their organisation's setting, its test groups and
/// its runners (Andy: an organisation tries a build on some of its runners
/// before the rest).
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum Reach {
    Site,
    Org(String),
}

impl Reach {
    fn holds_runner(&self, r: &runners::Runner) -> bool {
        match self {
            Reach::Site => true,
            Reach::Org(o) => r.scope_owner == *o,
        }
    }

    fn holds_group(&self, g: &Group) -> bool {
        match self {
            Reach::Site => true,
            Reach::Org(o) => g.owner == *o,
        }
    }
}

/// What a page shows of runner updates, within `reach`.
pub struct UpdateViews {
    pub site: PolicyView,
    pub owners: Vec<PolicyView>,
    pub groups: Vec<GroupView>,
    pub runners: Vec<RunnerView>,
}

pub async fn views(app: &Shared, reach: &Reach) -> sqlx::Result<UpdateViews> {
    let levels = Levels::load(&app.db).await?;
    let all = runners::list(&app.db).await?;
    let policy = |scope: &str, key: &str| {
        levels.policies.get(&(scope.to_string(), key.to_string())).cloned().unwrap_or(Policy {
            scope: scope.into(),
            key: key.into(),
            ..Policy::default()
        })
    };
    let mut owners: Vec<PolicyView> = match reach {
        Reach::Site => {
            levels.policies.values().filter(|p| p.scope == "owner").map(|p| PolicyView::of(p, format!("owner {}", p.key))).collect()
        }
        Reach::Org(o) => vec![PolicyView::of(&policy("owner", o), format!("owner {o}"))],
    };
    owners.sort_by(|a, b| a.key.cmp(&b.key));
    let groups = levels
        .groups
        .iter()
        .filter(|g| reach.holds_group(g))
        .map(|g| GroupView {
            g: g.clone(),
            reach: if g.owner.is_empty() { "the site's runners".into() } else { format!("{}'s runners", g.owner) },
            members: all.iter().filter(|r| levels.member(g, r)).map(|r| r.name.clone()).collect(),
            chosen: levels.chosen.iter().filter(|(gid, _)| *gid == g.id).map(|(_, r)| *r).collect(),
            policy: PolicyView::of(&policy("group", &g.id.to_string()), format!("group {}", g.name)),
        })
        .collect();
    let hour = time::OffsetDateTime::now_utc().hour();
    let mut out = vec![];
    for r in all.into_iter().filter(|r| reach.holds_runner(r)) {
        let effective = levels.resolve(&r);
        let (_, offer) = ru::offer(&app.db, &r, &effective, hour).await?;
        out.push(RunnerView {
            groups: levels.groups_of(&r).iter().map(|g| g.name.clone()).collect(),
            policy: PolicyView::of(&policy("runner", &r.id.to_string()), format!("runner {}", r.name)),
            effective,
            offer,
            r,
        });
    }
    Ok(UpdateViews { site: PolicyView::of(&policy("site", ""), "the site".into()), owners, groups, runners: out })
}

async fn page(app: &Shared, shell: Shell, notice: Option<String>, error: Option<String>) -> Result<Page<UpdatesPage>, Error> {
    let e = |e| Error::from_db(shell.clone(), e);
    let repo = accounts::setting(&app.db, ru::SETTING_REPO).await.map_err(e)?.unwrap_or_default();
    let v = views(app, &Reach::Site).await.map_err(e)?;
    let holds = rdb::holds(&app.db).await.map_err(e)?;
    Ok(Page(UpdatesPage { shell, repo, site: v.site, owners: v.owners, groups: v.groups, runners: v.runners, holds, notice, error }))
}

/// What a change did, to say on the page: `Ok` a notice, `Err` what was wrong.
pub type Outcome = Result<String, String>;

/// [`page`] saying what `outcome` did.
async fn page_after(app: &Shared, shell: Shell, outcome: Outcome) -> Result<Page<UpdatesPage>, Error> {
    match outcome {
        Ok(n) => page(app, shell, Some(n), None).await,
        Err(why) => page(app, shell, None, Some(why)).await,
    }
}

pub async fn show(State(app): State<Shared>, viewer: Viewer) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    require_admin(&viewer, &shell)?;
    page(&app, shell, None, None).await
}

#[derive(Deserialize)]
pub struct SourceForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    repo: String,
}

/// `POST /admin/runners/updates/source`: the repository whose releases carry runner builds.
pub async fn save_source(State(app): State<Shared>, viewer: Viewer, Form(f): Form<SourceForm>) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let repo = f.repo.trim().trim_matches('/').to_string();
    if !repo.is_empty() {
        let found = match repo.split_once('/') {
            Some((o, n)) => crate::db::repos::get(&app.db, o, n).await.map_err(|e| Error::from_db(shell.clone(), e))?,
            None => None,
        };
        if found.is_none() {
            return page(&app, shell, None, Some(format!("There is no repository {repo:?} here; give it as owner/name."))).await;
        }
    }
    accounts::set_setting(&app.db, ru::SETTING_REPO, &repo).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(&app.db, Some(&me), "runner.updates.source", &repo, "runner builds come from its releases").await.ok();
    let n = if repo.is_empty() {
        "Saved: no repository, so no runner is offered a build.".into()
    } else {
        format!("Saved: runner builds come from {repo}'s releases.")
    };
    page(&app, shell, Some(n), None).await
}

#[derive(Deserialize)]
pub struct PolicyForm {
    #[serde(rename = "_csrf")]
    pub(crate) csrf_token: String,
    scope: String,
    #[serde(default)]
    key: String,
    #[serde(default)]
    updates: String,
    #[serde(default)]
    channel: String,
    #[serde(default)]
    window: String,
    #[serde(default)]
    dry_run: String,
}

/// Set one level's settings, within `reach`.
pub async fn apply_policy(app: &Shared, me: &accounts::Account, reach: &Reach, f: &PolicyForm) -> sqlx::Result<Outcome> {
    let key = f.key.trim().to_string();
    let label = match (f.scope.as_str(), reach) {
        ("site", Reach::Site) if key.is_empty() => "the site".to_string(),
        ("owner", Reach::Org(o)) if key != *o => return Ok(Err("An organisation sets its own runners' updates only.".into())),
        ("owner", _) => {
            let known = accounts::account_by_name(&app.db, &key).await?.is_some() || accounts::org_by_name(&app.db, &key).await?.is_some();
            if !known {
                return Ok(Err(format!("There is no account or organisation {key:?}.")));
            }
            format!("owner {key}")
        }
        ("group", _) => match key.parse().ok() {
            Some(id) => match rdb::group(&app.db, id).await?.filter(|g| reach.holds_group(g)) {
                Some(g) => format!("group {}", g.name),
                None => return Ok(Err("That test group is gone.".into())),
            },
            None => return Ok(Err("That test group is gone.".into())),
        },
        ("runner", _) => match key.parse().ok() {
            Some(id) => match runners::get(&app.db, id).await?.filter(|r| reach.holds_runner(r)) {
                Some(r) => format!("runner {}", r.name),
                None => return Ok(Err("That runner is gone.".into())),
            },
            None => return Ok(Err("That runner is gone.".into())),
        },
        _ => return Ok(Err("Choose the site, an owner, a test group or a runner.".into())),
    };
    let tri = |v: &str| match v {
        "on" => Some(true),
        "off" => Some(false),
        _ => None,
    };
    let channel = f.channel.trim().to_string();
    if !channel.is_empty() && !ru::valid_channel(&channel) {
        return Ok(Err(format!("A channel is stable, canary or a version such as 0.3.4, not {channel:?}.")));
    }
    let window = match ru::parse_window(&f.window) {
        Ok(w) => w,
        Err(why) => return Ok(Err(format!("{why}."))),
    };
    let p = Policy {
        scope: f.scope.clone(),
        key,
        updates: tri(&f.updates),
        channel: Some(channel).filter(|c| !c.is_empty()),
        window_from: window.map(|w| w.0 as i64),
        window_to: window.map(|w| w.1 as i64),
        dry_run: tri(&f.dry_run),
    };
    rdb::set_policy(&app.db, &p).await?;
    let words = PolicyView::of(&p, label.clone()).summary();
    accounts::audit(&app.db, Some(me), "runner.updates.policy", &label, &words).await.ok();
    Ok(Ok(format!("Saved for {label}: {words}.")))
}

/// `POST /admin/runners/updates/policy`: one level's settings.
pub async fn save_policy(State(app): State<Shared>, viewer: Viewer, Form(f): Form<PolicyForm>) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let outcome = apply_policy(&app, &me, &Reach::Site, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    page_after(&app, shell, outcome).await
}

#[derive(Deserialize)]
pub struct GroupForm {
    #[serde(rename = "_csrf")]
    pub(crate) csrf_token: String,
    #[serde(default)]
    owner: String,
    #[serde(default)]
    name: String,
    /// `percent` or `chosen`.
    #[serde(default)]
    mode: String,
    #[serde(default)]
    percent: String,
    #[serde(default)]
    runner: Vec<i64>,
}

/// The percentage a form gives, or why it cannot be one.
fn percent_of(f: &GroupForm) -> Result<Option<i64>, String> {
    if f.mode != "percent" {
        return Ok(None);
    }
    match f.percent.trim().trim_end_matches('%').parse::<i64>() {
        Ok(p) if (1..=100).contains(&p) => Ok(Some(p)),
        _ => Err("A percentage is a whole number from 1 to 100.".into()),
    }
}

/// The chosen runners a form names that `owner`'s group may hold.
async fn chosen_in_reach(app: &Shared, owner: &str, f: &GroupForm) -> sqlx::Result<Vec<i64>> {
    let all = runners::list(&app.db).await?;
    Ok(f.runner.iter().copied().filter(|id| all.iter().any(|r| r.id == *id && (owner.is_empty() || r.scope_owner == owner))).collect())
}

/// Make a test group, within `reach` (an organisation's are its own).
pub async fn apply_create_group(app: &Shared, me: &accounts::Account, reach: &Reach, f: &GroupForm) -> sqlx::Result<Outcome> {
    let name = f.name.trim().to_string();
    if name.is_empty() || name.len() > 60 {
        return Ok(Err("A test group needs a name of up to 60 characters.".into()));
    }
    let owner = match reach {
        Reach::Site => f.owner.trim().to_string(),
        Reach::Org(o) => o.clone(),
    };
    if !owner.is_empty()
        && accounts::account_by_name(&app.db, &owner).await?.is_none()
        && accounts::org_by_name(&app.db, &owner).await?.is_none()
    {
        return Ok(Err(format!("There is no account or organisation {owner:?}.")));
    }
    let percent = match percent_of(f) {
        Ok(p) => p,
        Err(why) => return Ok(Err(why)),
    };
    if rdb::groups(&app.db).await?.iter().any(|g| g.owner == owner && g.name == name) {
        return Ok(Err(format!("There is already a test group {name:?} for those runners.")));
    }
    let chosen = chosen_in_reach(app, &owner, f).await?;
    let g = rdb::create_group(&app.db, &owner, &name, percent).await?;
    if percent.is_none() {
        rdb::set_members(&app.db, g.id, &chosen).await?;
    }
    let what = match percent {
        Some(p) => format!("{p}% of {}", if owner.is_empty() { "the site's runners".into() } else { format!("{owner}'s runners") }),
        None => format!("{} chosen runners", chosen.len()),
    };
    accounts::audit(&app.db, Some(me), "runner.updates.group", &name, &format!("created: {what}")).await.ok();
    Ok(Ok(format!("Test group {name} made: {what}. Give it its settings below.")))
}

/// `POST /admin/runners/updates/groups`: a new test group.
pub async fn create_group(
    State(app): State<Shared>,
    viewer: Viewer,
    axum_extra::extract::Form(f): axum_extra::extract::Form<GroupForm>,
) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let outcome = apply_create_group(&app, &me, &Reach::Site, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    page_after(&app, shell, outcome).await
}

/// Set who is in test group `id`, within `reach`.
pub async fn apply_save_group(app: &Shared, me: &accounts::Account, reach: &Reach, id: i64, f: &GroupForm) -> sqlx::Result<Outcome> {
    let Some(g) = rdb::group(&app.db, id).await?.filter(|g| reach.holds_group(g)) else {
        return Ok(Err("That test group is gone.".into()));
    };
    let percent = match percent_of(f) {
        Ok(p) => p,
        Err(why) => return Ok(Err(why)),
    };
    let chosen = if percent.is_some() { vec![] } else { chosen_in_reach(app, &g.owner, f).await? };
    rdb::set_percent(&app.db, id, percent).await?;
    rdb::set_members(&app.db, id, &chosen).await?;
    let what = match percent {
        Some(p) => format!("{p}% of its runners"),
        None => format!("{} chosen runners", chosen.len()),
    };
    accounts::audit(&app.db, Some(me), "runner.updates.group", &g.name, &what).await.ok();
    Ok(Ok(format!("Test group {} is now {what}.", g.name)))
}

/// `POST /admin/runners/updates/groups/{id}`: who is in a test group.
pub async fn save_group(
    State(app): State<Shared>,
    viewer: Viewer,
    Path(id): Path<i64>,
    axum_extra::extract::Form(f): axum_extra::extract::Form<GroupForm>,
) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let outcome = apply_save_group(&app, &me, &Reach::Site, id, &f).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    page_after(&app, shell, outcome).await
}

#[derive(Deserialize)]
pub struct CsrfOnly {
    #[serde(rename = "_csrf")]
    pub(crate) csrf_token: String,
}

/// Remove test group `id`, within `reach`.
pub async fn apply_delete_group(app: &Shared, me: &accounts::Account, reach: &Reach, id: i64) -> sqlx::Result<Outcome> {
    let Some(g) = rdb::group(&app.db, id).await?.filter(|g| reach.holds_group(g)) else {
        return Ok(Err("That test group is gone.".into()));
    };
    rdb::delete_group(&app.db, id).await?;
    accounts::audit(&app.db, Some(me), "runner.updates.group", &g.name, "removed").await.ok();
    Ok(Ok(format!("Test group {} removed; its runners follow the levels above it.", g.name)))
}

/// `POST /admin/runners/updates/groups/{id}/delete`.
pub async fn delete_group(
    State(app): State<Shared>,
    viewer: Viewer,
    Path(id): Path<i64>,
    Form(f): Form<CsrfOnly>,
) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let outcome = apply_delete_group(&app, &me, &Reach::Site, id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    page_after(&app, shell, outcome).await
}

#[derive(Deserialize)]
pub struct LiftForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    version: String,
}

/// `POST /admin/runners/updates/holds/lift`: offer a held build again (#326).
pub async fn lift_hold(State(app): State<Shared>, viewer: Viewer, Form(f): Form<LiftForm>) -> Result<Page<UpdatesPage>, Error> {
    let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
    let me = require_admin(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let v = f.version.trim();
    if !rdb::lift(&app.db, v).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        return page(&app, shell, None, Some(format!("flow {v} is not held."))).await;
    }
    accounts::audit(&app.db, Some(&me), "runner.update.lifted", v, "offered again").await.ok();
    page(&app, shell, Some(format!("flow {v} is offered again where the settings say so.")), None).await
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! Admin → Runners → Updates (oxygenhub#322): where runner builds come
2		//! from, and who takes them: the site's, each owner's, each test group's
3		//! and each runner's settings, the nearest winning; test groups of chosen
4		//! runners or a percentage of them.
5
6		use super::settings::csrf;
7		use super::{filters, Error, Page, Shell};
8		use crate::auth::Viewer;
9		use crate::db::runner_updates::{self as rdb, Group, Policy};
10		use crate::db::{accounts, runners};
11		use crate::runner_updates::{self as ru, Levels};
12		use crate::Shared;
13		use askama::Template;
14		use axum::extract::{Form, Path, State};
15		use flow_core::api::UpdatePolicy;
16		use serde::Deserialize;
17
18	18×	fn require_admin(viewer: &Viewer, shell: &Shell) -> Result<accounts::Account, Error> {
19	18×	match viewer.account() {
20	17×	Some(a) if a.is_admin => Ok(a.clone()),
21	1×	_ => Err(Error::not_found(shell.clone())),
22		}
23	18×	}
24
25		/// One level's settings as its form shows them: `inherit`, `on` or `off`
26		/// for the switches, blank for an inherited channel or window.
27		pub struct PolicyView {
28		pub scope: String,
29		pub key: String,
30		pub label: String,
31		pub updates: &'static str,
32		pub channel: String,
33		pub window: String,
34		pub dry_run: &'static str,
35		}
36
37		impl PolicyView {
38	156×	fn of(p: &Policy, label: String) -> PolicyView {
39	312×	let tri = \|b: Option<bool>\| match b {
40	49×	Some(true) => "on",
41	17×	Some(false) => "off",
42	246×	None => "inherit",
43	312×	};
44		PolicyView {
45	156×	scope: p.scope.clone(),
46	156×	key: p.key.clone(),
47	156×	label,
48	156×	updates: tri(p.updates),
49	156×	channel: p.channel.clone().unwrap_or_default(),
50	156×	window: match (p.window_from, p.window_to) {
51	10×	(Some(a), Some(b)) => format!("{a:02}-{b:02}"),
52	146×	_ => String::new(),
53		},
54	156×	dry_run: tri(p.dry_run),
55		}
56	156×	}
57
58		/// The settings in words, for a table.
59	24×	pub fn summary(&self) -> String {
60	24×	let mut s = vec![];
61	24×	if self.updates != "inherit" {
62	18×	s.push(format!("updates {}", self.updates));
63	18×	}
64	24×	if !self.channel.is_empty() {
65	2×	s.push(format!("channel {}", self.channel));
66	22×	}
67	24×	if !self.window.is_empty() {
68	1×	s.push(format!("window {} UTC", self.window));
69	23×	}
70	24×	if self.dry_run != "inherit" {
71	13×	s.push(format!("dry run {}", self.dry_run));
72	13×	}
73	24×	if s.is_empty() {
74	5×	"inherits everything".into()
75		} else {
76	19×	s.join(", ")
77		}
78	24×	}
79		}
80
81		pub struct GroupView {
82		pub g: Group,
83		/// Whom it can hold, in words.
84		pub reach: String,
85		/// Its members now, by name.
86		pub members: Vec<String>,
87		pub chosen: Vec<i64>,
88		pub policy: PolicyView,
89		}
90
91		pub struct RunnerView {
92		pub r: runners::Runner,
93		pub groups: Vec<String>,
94		pub effective: UpdatePolicy,
95		/// What the hub would offer it now.
96		pub offer: String,
97		pub policy: PolicyView,
98		}
99
100		impl RunnerView {
101		/// Its effective settings, each with where it came from.
102	52×	pub fn effective_words(&self) -> String {
103	52×	let e = &self.effective;
104	52×	let mut s = vec![format!("updates {} ({})", if e.updates { "on" } else { "off" }, e.from[0])];
105	52×	if e.updates {
106	38×	s.push(format!("channel {} ({})", e.channel, e.from[1]));
107	38×	if let Some((a, b)) = e.window {
108	10×	s.push(format!("window {a:02}–{b:02} UTC ({})", e.from[2]));
109	28×	}
110	38×	if e.dry_run {
111	22×	s.push(format!("dry run ({})", e.from[3]));
112	22×	}
113	14×	}
114	52×	s.join(" · ")
115	52×	}
116		}
117
118		#[derive(Template)]
119		#[template(path = "admin_runner_updates.html")]
120		pub struct UpdatesPage {
121		shell: Shell,
122		repo: String,
123		site: PolicyView,
124		owners: Vec<PolicyView>,
125		groups: Vec<GroupView>,
126		runners: Vec<RunnerView>,
127		/// Builds held back after rolling back on a runner (#326).
128		holds: Vec<rdb::Hold>,
129		notice: Option<String>,
130		error: Option<String>,
131		}
132
133		/// Who changes runner updates: the site's administrators anything; an
134		/// organisation's owners their organisation's setting, its test groups and
135		/// its runners (Andy: an organisation tries a build on some of its runners
136		/// before the rest).
137		#[derive(Clone, Debug, PartialEq, Eq)]
138		pub enum Reach {
139		Site,
140		Org(String),
141		}
142
143		impl Reach {
144	68×	fn holds_runner(&self, r: &runners::Runner) -> bool {
145	68×	match self {
146	33×	Reach::Site => true,
147	35×	Reach::Org(o) => r.scope_owner == *o,
148		}
149	68×	}
150
151	26×	fn holds_group(&self, g: &Group) -> bool {
152	26×	match self {
153	17×	Reach::Site => true,
154	9×	Reach::Org(o) => g.owner == *o,
155		}
156	26×	}
157		}
158
159		/// What a page shows of runner updates, within `reach`.
160		pub struct UpdateViews {
161		pub site: PolicyView,
162		pub owners: Vec<PolicyView>,
163		pub groups: Vec<GroupView>,
164		pub runners: Vec<RunnerView>,
165		}
166
167	48×	pub async fn views(app: &Shared, reach: &Reach) -> sqlx::Result<UpdateViews> {
168	48×	let levels = Levels::load(&app.db).await?;
169	48×	let all = runners::list(&app.db).await?;
170	149×	let policy = \|scope: &str, key: &str\| {
171	149×	levels.policies.get(&(scope.to_string(), key.to_string())).cloned().unwrap_or(Policy {
172	149×	scope: scope.into(),
173	149×	key: key.into(),
174	149×	..Policy::default()
175	149×	})
176	149×	};
177	48×	let mut owners: Vec<PolicyView> = match reach {
178		Reach::Site => {
179	35×	levels.policies.values().filter(\|p\| p.scope == "owner").map(\|p\| PolicyView::of(p, format!("owner {}", p.key))).collect()
180		}
181	31×	Reach::Org(o) => vec![PolicyView::of(&policy("owner", o), format!("owner {o}"))],
182		};
183	48×	owners.sort_by(\|a, b\| a.key.cmp(&b.key));
184	48×	let groups = levels
185	48×	.groups
186	48×	.iter()
187	48×	.filter(\|g\| reach.holds_group(g))
188	48×	.map(\|g\| GroupView {
189	18×	g: g.clone(),
190	18×	reach: if g.owner.is_empty() { "the site's runners".into() } else { format!("{}'s runners", g.owner) },
191	41×	members: all.iter().filter(\|r\| levels.member(g, r)).map(\|r\| r.name.clone()).collect(),
192	18×	chosen: levels.chosen.iter().filter(\|(gid, _)\| gid == g.id).map(\|(_, r)\| r).collect(),
193	18×	policy: PolicyView::of(&policy("group", &g.id.to_string()), format!("group {}", g.name)),
194	18×	})
195	48×	.collect();
196	48×	let hour = time::OffsetDateTime::now_utc().hour();
197	48×	let mut out = vec![];
198	65×	for r in all.into_iter().filter(\|r\| reach.holds_runner(r)) {
199	52×	let effective = levels.resolve(&r);
200	52×	let (_, offer) = ru::offer(&app.db, &r, &effective, hour).await?;
201	52×	out.push(RunnerView {
202	52×	groups: levels.groups_of(&r).iter().map(\|g\| g.name.clone()).collect(),
203	52×	policy: PolicyView::of(&policy("runner", &r.id.to_string()), format!("runner {}", r.name)),
204	52×	effective,
205	52×	offer,
206	52×	r,
207		});
208		}
209	48×	Ok(UpdateViews { site: PolicyView::of(&policy("site", ""), "the site".into()), owners, groups, runners: out })
210	48×	}
211
212	17×	async fn page(app: &Shared, shell: Shell, notice: Option<String>, error: Option<String>) -> Result<Page<UpdatesPage>, Error> {
213	17×	let e = \|e\| Error::from_db(shell.clone(), e);
214	17×	let repo = accounts::setting(&app.db, ru::SETTING_REPO).await.map_err(e)?.unwrap_or_default();
215	17×	let v = views(app, &Reach::Site).await.map_err(e)?;
216	17×	let holds = rdb::holds(&app.db).await.map_err(e)?;
217	17×	Ok(Page(UpdatesPage { shell, repo, site: v.site, owners: v.owners, groups: v.groups, runners: v.runners, holds, notice, error }))
218	17×	}
219
220		/// What a change did, to say on the page: `Ok` a notice, `Err` what was wrong.
221		pub type Outcome = Result<String, String>;
222
223		/// [`page`] saying what `outcome` did.
224	10×	async fn page_after(app: &Shared, shell: Shell, outcome: Outcome) -> Result<Page<UpdatesPage>, Error> {
225	10×	match outcome {
226	7×	Ok(n) => page(app, shell, Some(n), None).await,
227	3×	Err(why) => page(app, shell, None, Some(why)).await,
228		}
229	10×	}
230
231	4×	pub async fn show(State(app): State<Shared>, viewer: Viewer) -> Result<Page<UpdatesPage>, Error> {
232	4×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
233	4×	require_admin(&viewer, &shell)?;
234	3×	page(&app, shell, None, None).await
235	4×	}
236
237		#[derive(Deserialize)]
238		pub struct SourceForm {
239		#[serde(rename = "_csrf")]
240		csrf_token: String,
241		repo: String,
242		}
243
244		/// `POST /admin/runners/updates/source`: the repository whose releases carry runner builds.
245	2×	pub async fn save_source(State(app): State<Shared>, viewer: Viewer, Form(f): Form<SourceForm>) -> Result<Page<UpdatesPage>, Error> {
246	2×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
247	2×	let me = require_admin(&viewer, &shell)?;
248	2×	csrf(&viewer, &f.csrf_token, &shell)?;
249	2×	let repo = f.repo.trim().trim_matches('/').to_string();
250	2×	if !repo.is_empty() {
251	2×	let found = match repo.split_once('/') {
252	2×	Some((o, n)) => crate::db::repos::get(&app.db, o, n).await.map_err(\|e\| Error::from_db(shell.clone(), e))?,
253	0×	None => None,
254		};
255	2×	if found.is_none() {
256	1×	return page(&app, shell, None, Some(format!("There is no repository {repo:?} here; give it as owner/name."))).await;
257	1×	}
258	0×	}
259	1×	accounts::set_setting(&app.db, ru::SETTING_REPO, &repo).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
260	1×	accounts::audit(&app.db, Some(&me), "runner.updates.source", &repo, "runner builds come from its releases").await.ok();
261	1×	let n = if repo.is_empty() {
262	0×	"Saved: no repository, so no runner is offered a build.".into()
263		} else {
264	1×	format!("Saved: runner builds come from {repo}'s releases.")
265		};
266	1×	page(&app, shell, Some(n), None).await
267	2×	}
268
269		#[derive(Deserialize)]
270		pub struct PolicyForm {
271		#[serde(rename = "_csrf")]
272		pub(crate) csrf_token: String,
273		scope: String,
274		#[serde(default)]
275		key: String,
276		#[serde(default)]
277		updates: String,
278		#[serde(default)]
279		channel: String,
280		#[serde(default)]
281		window: String,
282		#[serde(default)]
283		dry_run: String,
284		}
285
286		/// Set one level's settings, within `reach`.
287	12×	pub async fn apply_policy(app: &Shared, me: &accounts::Account, reach: &Reach, f: &PolicyForm) -> sqlx::Result<Outcome> {
288	12×	let key = f.key.trim().to_string();
289	12×	let label = match (f.scope.as_str(), reach) {
290	12×	("site", Reach::Site) if key.is_empty() => "the site".to_string(),
291	8×	("owner", Reach::Org(o)) if key != *o => return Ok(Err("An organisation sets its own runners' updates only.".into())),
292		("owner", _) => {
293	1×	let known = accounts::account_by_name(&app.db, &key).await?.is_some() \|\| accounts::org_by_name(&app.db, &key).await?.is_some();
294	1×	if !known {
295	0×	return Ok(Err(format!("There is no account or organisation {key:?}.")));
296	1×	}
297	1×	format!("owner {key}")
298		}
299	6×	("group", _) => match key.parse().ok() {
300	3×	Some(id) => match rdb::group(&app.db, id).await?.filter(\|g\| reach.holds_group(g)) {
301	3×	Some(g) => format!("group {}", g.name),
302	0×	None => return Ok(Err("That test group is gone.".into())),
303		},
304	0×	None => return Ok(Err("That test group is gone.".into())),
305		},
306	3×	("runner", _) => match key.parse().ok() {
307	3×	Some(id) => match runners::get(&app.db, id).await?.filter(\|r\| reach.holds_runner(r)) {
308	2×	Some(r) => format!("runner {}", r.name),
309	1×	None => return Ok(Err("That runner is gone.".into())),
310		},
311	0×	None => return Ok(Err("That runner is gone.".into())),
312		},
313	1×	_ => return Ok(Err("Choose the site, an owner, a test group or a runner.".into())),
314		};
315	14×	let tri = \|v: &str\| match v {
316	14×	"on" => Some(true),
317	9×	"off" => Some(false),
318	7×	_ => None,
319	14×	};
320	9×	let channel = f.channel.trim().to_string();
321	9×	if !channel.is_empty() && !ru::valid_channel(&channel) {
322	1×	return Ok(Err(format!("A channel is stable, canary or a version such as 0.3.4, not {channel:?}.")));
323	8×	}
324	8×	let window = match ru::parse_window(&f.window) {
325	7×	Ok(w) => w,
326	1×	Err(why) => return Ok(Err(format!("{why}."))),
327		};
328	7×	let p = Policy {
329	7×	scope: f.scope.clone(),
330	7×	key,
331	7×	updates: tri(&f.updates),
332	7×	channel: Some(channel).filter(\|c\| !c.is_empty()),
333	7×	window_from: window.map(\|w\| w.0 as i64),
334	7×	window_to: window.map(\|w\| w.1 as i64),
335	7×	dry_run: tri(&f.dry_run),
336		};
337	7×	rdb::set_policy(&app.db, &p).await?;
338	7×	let words = PolicyView::of(&p, label.clone()).summary();
339	7×	accounts::audit(&app.db, Some(me), "runner.updates.policy", &label, &words).await.ok();
340	7×	Ok(Ok(format!("Saved for {label}: {words}.")))
341	12×	}
342
343		/// `POST /admin/runners/updates/policy`: one level's settings.
344	6×	pub async fn save_policy(State(app): State<Shared>, viewer: Viewer, Form(f): Form<PolicyForm>) -> Result<Page<UpdatesPage>, Error> {
345	6×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
346	6×	let me = require_admin(&viewer, &shell)?;
347	6×	csrf(&viewer, &f.csrf_token, &shell)?;
348	6×	let outcome = apply_policy(&app, &me, &Reach::Site, &f).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
349	6×	page_after(&app, shell, outcome).await
350	6×	}
351
352		#[derive(Deserialize)]
353		pub struct GroupForm {
354		#[serde(rename = "_csrf")]
355		pub(crate) csrf_token: String,
356		#[serde(default)]
357		owner: String,
358		#[serde(default)]
359		name: String,
360		/// `percent` or `chosen`.
361		#[serde(default)]
362		mode: String,
363		#[serde(default)]
364		percent: String,
365		#[serde(default)]
366		runner: Vec<i64>,
367		}
368
369		/// The percentage a form gives, or why it cannot be one.
370	4×	fn percent_of(f: &GroupForm) -> Result<Option<i64>, String> {
371	4×	if f.mode != "percent" {
372	2×	return Ok(None);
373	2×	}
374	2×	match f.percent.trim().trim_end_matches('%').parse::<i64>() {
375	2×	Ok(p) if (1..=100).contains(&p) => Ok(Some(p)),
376	1×	_ => Err("A percentage is a whole number from 1 to 100.".into()),
377		}
378	4×	}
379
380		/// The chosen runners a form names that `owner`'s group may hold.
381	2×	async fn chosen_in_reach(app: &Shared, owner: &str, f: &GroupForm) -> sqlx::Result<Vec<i64>> {
382	2×	let all = runners::list(&app.db).await?;
383	6×	Ok(f.runner.iter().copied().filter(\|id\| all.iter().any(\|r\| r.id == *id && (owner.is_empty() \|\| r.scope_owner == owner))).collect())
384	2×	}
385
386		/// Make a test group, within `reach` (an organisation's are its own).
387	3×	pub async fn apply_create_group(app: &Shared, me: &accounts::Account, reach: &Reach, f: &GroupForm) -> sqlx::Result<Outcome> {
388	3×	let name = f.name.trim().to_string();
389	3×	if name.is_empty() \|\| name.len() > 60 {
390	0×	return Ok(Err("A test group needs a name of up to 60 characters.".into()));
391	3×	}
392	3×	let owner = match reach {
393	2×	Reach::Site => f.owner.trim().to_string(),
394	1×	Reach::Org(o) => o.clone(),
395		};
396	3×	if !owner.is_empty()
397	1×	&& accounts::account_by_name(&app.db, &owner).await?.is_none()
398	1×	&& accounts::org_by_name(&app.db, &owner).await?.is_none()
399		{
400	0×	return Ok(Err(format!("There is no account or organisation {owner:?}.")));
401	3×	}
402	3×	let percent = match percent_of(f) {
403	2×	Ok(p) => p,
404	1×	Err(why) => return Ok(Err(why)),
405		};
406	2×	if rdb::groups(&app.db).await?.iter().any(\|g\| g.owner == owner && g.name == name) {
407	0×	return Ok(Err(format!("There is already a test group {name:?} for those runners.")));
408	2×	}
409	2×	let chosen = chosen_in_reach(app, &owner, f).await?;
410	2×	let g = rdb::create_group(&app.db, &owner, &name, percent).await?;
411	2×	if percent.is_none() {
412	2×	rdb::set_members(&app.db, g.id, &chosen).await?;
413	0×	}
414	2×	let what = match percent {
415	0×	Some(p) => format!("{p}% of {}", if owner.is_empty() { "the site's runners".into() } else { format!("{owner}'s runners") }),
416	2×	None => format!("{} chosen runners", chosen.len()),
417		};
418	2×	accounts::audit(&app.db, Some(me), "runner.updates.group", &name, &format!("created: {what}")).await.ok();
419	2×	Ok(Ok(format!("Test group {name} made: {what}. Give it its settings below.")))
420	3×	}
421
422		/// `POST /admin/runners/updates/groups`: a new test group.
423	2×	pub async fn create_group(
424	2×	State(app): State<Shared>,
425	2×	viewer: Viewer,
426	2×	axum_extra::extract::Form(f): axum_extra::extract::Form<GroupForm>,
427	2×	) -> Result<Page<UpdatesPage>, Error> {
428	2×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
429	2×	let me = require_admin(&viewer, &shell)?;
430	2×	csrf(&viewer, &f.csrf_token, &shell)?;
431	2×	let outcome = apply_create_group(&app, &me, &Reach::Site, &f).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
432	2×	page_after(&app, shell, outcome).await
433	2×	}
434
435		/// Set who is in test group `id`, within `reach`.
436	1×	pub async fn apply_save_group(app: &Shared, me: &accounts::Account, reach: &Reach, id: i64, f: &GroupForm) -> sqlx::Result<Outcome> {
437	1×	let Some(g) = rdb::group(&app.db, id).await?.filter(\|g\| reach.holds_group(g)) else {
438	0×	return Ok(Err("That test group is gone.".into()));
439		};
440	1×	let percent = match percent_of(f) {
441	1×	Ok(p) => p,
442	0×	Err(why) => return Ok(Err(why)),
443		};
444	1×	let chosen = if percent.is_some() { vec![] } else { chosen_in_reach(app, &g.owner, f).await? };
445	1×	rdb::set_percent(&app.db, id, percent).await?;
446	1×	rdb::set_members(&app.db, id, &chosen).await?;
447	1×	let what = match percent {
448	1×	Some(p) => format!("{p}% of its runners"),
449	0×	None => format!("{} chosen runners", chosen.len()),
450		};
451	1×	accounts::audit(&app.db, Some(me), "runner.updates.group", &g.name, &what).await.ok();
452	1×	Ok(Ok(format!("Test group {} is now {what}.", g.name)))
453	1×	}
454
455		/// `POST /admin/runners/updates/groups/{id}`: who is in a test group.
456	1×	pub async fn save_group(
457	1×	State(app): State<Shared>,
458	1×	viewer: Viewer,
459	1×	Path(id): Path<i64>,
460	1×	axum_extra::extract::Form(f): axum_extra::extract::Form<GroupForm>,
461	1×	) -> Result<Page<UpdatesPage>, Error> {
462	1×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
463	1×	let me = require_admin(&viewer, &shell)?;
464	1×	csrf(&viewer, &f.csrf_token, &shell)?;
465	1×	let outcome = apply_save_group(&app, &me, &Reach::Site, id, &f).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
466	1×	page_after(&app, shell, outcome).await
467	1×	}
468
469		#[derive(Deserialize)]
470		pub struct CsrfOnly {
471		#[serde(rename = "_csrf")]
472		pub(crate) csrf_token: String,
473		}
474
475		/// Remove test group `id`, within `reach`.
476	2×	pub async fn apply_delete_group(app: &Shared, me: &accounts::Account, reach: &Reach, id: i64) -> sqlx::Result<Outcome> {
477	2×	let Some(g) = rdb::group(&app.db, id).await?.filter(\|g\| reach.holds_group(g)) else {
478	1×	return Ok(Err("That test group is gone.".into()));
479		};
480	1×	rdb::delete_group(&app.db, id).await?;
481	1×	accounts::audit(&app.db, Some(me), "runner.updates.group", &g.name, "removed").await.ok();
482	1×	Ok(Ok(format!("Test group {} removed; its runners follow the levels above it.", g.name)))
483	2×	}
484
485		/// `POST /admin/runners/updates/groups/{id}/delete`.
486	1×	pub async fn delete_group(
487	1×	State(app): State<Shared>,
488	1×	viewer: Viewer,
489	1×	Path(id): Path<i64>,
490	1×	Form(f): Form<CsrfOnly>,
491	1×	) -> Result<Page<UpdatesPage>, Error> {
492	1×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
493	1×	let me = require_admin(&viewer, &shell)?;
494	1×	csrf(&viewer, &f.csrf_token, &shell)?;
495	1×	let outcome = apply_delete_group(&app, &me, &Reach::Site, id).await.map_err(\|e\| Error::from_db(shell.clone(), e))?;
496	1×	page_after(&app, shell, outcome).await
497	1×	}
498
499		#[derive(Deserialize)]
500		pub struct LiftForm {
501		#[serde(rename = "_csrf")]
502		csrf_token: String,
503		version: String,
504		}
505
506		/// `POST /admin/runners/updates/holds/lift`: offer a held build again (#326).
507	2×	pub async fn lift_hold(State(app): State<Shared>, viewer: Viewer, Form(f): Form<LiftForm>) -> Result<Page<UpdatesPage>, Error> {
508	2×	let shell = Shell::new(&app, "/admin/runners/updates", &viewer);
509	2×	let me = require_admin(&viewer, &shell)?;
510	2×	csrf(&viewer, &f.csrf_token, &shell)?;
511	2×	let v = f.version.trim();
512	2×	if !rdb::lift(&app.db, v).await.map_err(\|e\| Error::from_db(shell.clone(), e))? {
513	1×	return page(&app, shell, None, Some(format!("flow {v} is not held."))).await;
514	1×	}
515	1×	accounts::audit(&app.db, Some(&me), "runner.update.lifted", v, "offered again").await.ok();
516	1×	page(&app, shell, Some(format!("flow {v} is offered again where the settings say so.")), None).await
517	2×	}

Coverage / crates/hub/src/web/runner_updates.rs 92.5%

Keyboard