Flow priorities: an organisation's level, and a cap on expedited runs 76f93eaefe45

    /// Its repositories' Flow priority (oxygenhub#244): `low`, `normal`,

    /// `high`, or empty to follow the site's (migration 0073).

    #[sqlx(default)]

    pub flow_priority: String,

}

pub async fn set_org_flow_priority(pool: &Pool, org_id: i64, priority: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE organisations SET flow_priority = $1 WHERE id = $2").bind(priority).bind(org_id).execute(pool).await?;

    Ok(())

/// How many runs of `owner`'s repositories are expedited and still live.

pub async fn expedited_live(pool: &Pool, owner: &str) -> sqlx::Result<i64> {

    sqlx::query_scalar(

        "SELECT COUNT(*) FROM flow_runs r JOIN repositories rep ON rep.id = r.repo_id \

         WHERE rep.owner = $1 AND r.priority = 'urgent' AND r.status IN ('queued', 'running')",

    )

    .bind(owner)

    .fetch_one(pool)

    .await

}

    // A cap on one owner's urgent runs at once (Admin > Runners >

    // Settings), so urgent can't starve everyone else.

    let cap: i64 = db::accounts::setting(&app.db, "flow_expedite_cap").await.ok().flatten().and_then(|v| v.parse().ok()).unwrap_or(2);

    let live = fdb::expedited_live(&app.db, &owner).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if live >= cap {

        let msg = format!("{owner} already has {live} expedited run(s) going, the most at once ({cap}); wait for one to end.");

        return Ok(Redirect::to(&format!("/{owner}/{name}/flow?error={}", urlencoding(&msg))).into_response());

    }

        .route("/orgs/{name}/settings/flow-priority", post(orgs::flow_priority))

pub struct PriorityForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    priority: String,

}

/// `POST /orgs/{name}/settings/flow-priority` (oxygenhub#244): its

/// repositories' Flow level unless one sets its own. Owners choose low,

/// normal or the site's; only site administrators raise one to high.

pub async fn flow_priority(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(name): Path<String>,

    Form(f): Form<PriorityForm>,

) -> Result<Page<OrgSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/orgs/{name}/settings"), &viewer);

    let (me, org) = owned_org(&app, &shell, &viewer, &name).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let level = match f.priority.as_str() {

        "low" | "normal" | "high" => f.priority.as_str(),

        "default" => "",

        _ => return org_page(&app, shell, org, None, Some("Pick low, normal, high or the site's.".into())).await,

    };

    if level == "high" && !viewer.is_admin() {

        return org_page(&app, shell, org, None, Some("Only site administrators raise an organisation to high.".into())).await;

    }

    accounts::set_org_flow_priority(&app.db, org.id, level).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "org.flow_priority", &org.name, if level.is_empty() { "default" } else { level }).await.ok();

    let org = accounts::org_by_name(&app.db, &name).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(org);

    org_page(&app, shell, org, Some("Saved.".into()), None).await

}

#[derive(Deserialize)]

    /// The most expedited runs one owner may have going at once.

    expedite_cap: i64,

        expedite_cap: accounts::setting(&app.db, "flow_expedite_cap").await.ok().flatten().and_then(|v| v.parse().ok()).unwrap_or(2),

    #[serde(default)]

    expedite_cap: Option<String>,

    let cap = match f.expedite_cap.as_deref().map(str::trim) {

        None | Some("") => None,

        Some(v) => match v.parse::<i64>() {

            Ok(n) if (0..=100).contains(&n) => Some(n),

            _ => return Ok(settings_page(&app, shell, None, Some("The cap is a whole number from 0 to 100.".into())).await),

        },

    };

    if let Some(n) = cap {

        accounts::set_setting(&app.db, "flow_expedite_cap", &n.to_string()).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    }

    // What the cap on expedited runs counts: andy's live urgent runs.

    assert_eq!(db::flow::expedited_live(&h.app.db, "andy").await.unwrap(), 1);

    assert_eq!(db::flow::expedited_live(&h.app.db, "someone-else").await.unwrap(), 0);

  <label for="expedite-cap">The most expedited runs one owner may have going at once</label>

  <input type="number" id="expedite-cap" name="expedite_cap" min="0" max="100" value="{{ expedite_cap }}">

<form class="card" id="flow-priority" method="post" action="/orgs/{{ org.name }}/settings/flow-priority">

  <input type="hidden" name="_csrf" value="{{ shell.csrf }}">

  <h2>OxygenFlow priority</h2>

  <p class="small">Runners take higher levels first; within a level, repositories take turns. A repository may set its own level, and a maintainer can expedite one run.</p>

  <select name="priority" aria-label="Priority">

    <option value="default"{% if org.flow_priority.is_empty() %} selected{% endif %}>the site's</option>

    {% if shell.is_admin %}<option value="high"{% if org.flow_priority == "high" %} selected{% endif %}>high</option>{% endif %}

    <option value="normal"{% if org.flow_priority == "normal" %} selected{% endif %}>normal</option>

    <option value="low"{% if org.flow_priority == "low" %} selected{% endif %}>low</option>

  </select>

  <button type="submit">Save</button>

</form>