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

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())),

}

    fn of(p: &Policy, label: String) -> PolicyView {

        let tri = |b: Option<bool>| match b {

            Some(true) => "on",

            Some(false) => "off",

            None => "inherit",

        };

            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),

    }

    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()

            s.join(", ")

    }

    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(" · ")

    }

    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,

    }

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 {

            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)?;

    Ok(Page(UpdatesPage { shell, repo, site: v.site, owners: v.owners, groups: v.groups, runners: v.runners, notice, error }))

}

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

}

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))?,

        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() {

        format!("Saved: runner builds come from {repo}'s releases.")

    page(&app, shell, Some(n), None).await

}

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())),

            let known = accounts::account_by_name(&app.db, &key).await?.is_some() || accounts::org_by_name(&app.db, &key).await?.is_some();

            if !known {

            }

            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),

        ("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())),

        _ => 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}.")))

}

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

}

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()),

}

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())

}

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 {

    }

    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()

    }

    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) {

    }

    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 {

        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.")))

}

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))?;