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

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

    }

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 levels = Levels::load(&app.db).await.map_err(e)?;

    let all = runners::list(&app.db).await.map_err(e)?;

    let repo = accounts::setting(&app.db, ru::SETTING_REPO).await.map_err(e)?.unwrap_or_default();

    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> =

        levels.policies.values().filter(|p| p.scope == "owner").map(|p| PolicyView::of(p, format!("owner {}", p.key))).collect();

    owners.sort_by(|a, b| a.key.cmp(&b.key));

    let groups = levels

        .groups

        .iter()

        .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 views = vec![];

    for r in all {

        let effective = levels.resolve(&r);

        let (_, offer) = ru::offer(&app.db, &r, &effective, hour).await.map_err(e)?;

        views.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(Page(UpdatesPage {

        site: PolicyView::of(&policy("site", ""), "the site".into()),

        shell,

        repo,

        owners,

        groups,

        runners: views,

        notice,

        error,

    }))

}

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 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 e = |e| Error::from_db(shell.clone(), e);

    let key = f.key.trim().to_string();

    let label = match f.scope.as_str() {

        "site" if key.is_empty() => "the site".to_string(),

        "owner" => {

        "group" => match key.parse().ok().map(|id| rdb::group(&app.db, id)) {

            Some(g) => match g.await.map_err(e)? {

                Some(g) => format!("group {}", g.name),

        "runner" => match key.parse().ok().map(|id| runners::get(&app.db, id)) {

            Some(r) => match r.await.map_err(e)? {

                Some(r) => format!("runner {}", r.name),

    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 page(&app, shell, None, Some(format!("A channel is stable, canary or a version such as 0.3.4, not {channel:?}."))).await;

    }

    let window = match ru::parse_window(&f.window) {

        Ok(w) => w,

        Err(why) => return page(&app, shell, None, Some(format!("{why}."))).await,

    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.map_err(e)?;

    let words = PolicyView::of(&p, label.clone()).summary();

    accounts::audit(&app.db, Some(&me), "runner.updates.policy", &label, &words).await.ok();

    page(&app, shell, Some(format!("Saved for {label}: {words}.")), None).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()),

}

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 e = |e| Error::from_db(shell.clone(), e);

    let name = f.name.trim().to_string();

    if name.is_empty() || name.len() > 60 {

    }

    let owner = f.owner.trim().to_string();

    if !owner.is_empty()

    }

    let percent = match percent_of(&f) {

        Ok(p) => p,

        Err(why) => return page(&app, shell, None, Some(why)).await,

    if rdb::groups(&app.db).await.map_err(e)?.iter().any(|g| g.owner == owner && g.name == name) {

    }

    let g = rdb::create_group(&app.db, &owner, &name, percent).await.map_err(e)?;

    if percent.is_none() {

        rdb::set_members(&app.db, g.id, &f.runner).await.map_err(e)?;

    let what = match percent {

        None => format!("{} chosen runners", f.runner.len()),

    accounts::audit(&app.db, Some(&me), "runner.updates.group", &name, &format!("created: {what}")).await.ok();

    page(&app, shell, Some(format!("Test group {name} made: {what}. Give it its settings below.")), None).await

}

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 e = |e| Error::from_db(shell.clone(), e);

    let Some(g) = rdb::group(&app.db, id).await.map_err(e)? else {

    let percent = match percent_of(&f) {

        Ok(p) => p,

    rdb::set_percent(&app.db, id, percent).await.map_err(e)?;

    rdb::set_members(&app.db, id, if percent.is_some() { &[] } else { &f.runner }).await.map_err(e)?;

    let what = match percent {

        Some(p) => format!("{p}% of its runners"),

    accounts::audit(&app.db, Some(&me), "runner.updates.group", &g.name, &what).await.ok();

    page(&app, shell, Some(format!("Test group {} is now {what}.", g.name)), None).await

}

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 e = |e| Error::from_db(shell.clone(), e);

    let Some(g) = rdb::group(&app.db, id).await.map_err(e)? else {

    rdb::delete_group(&app.db, id).await.map_err(e)?;

    accounts::audit(&app.db, Some(&me), "runner.updates.group", &g.name, "removed").await.ok();

    page(&app, shell, Some(format!("Test group {} removed; its runners follow the levels above it.", g.name)), None).await

}