Turn OxygenFlow on or off per repository in settings 9008bf6c2b8c

-- OxygenFlow per repository: 'on', 'off', or '' to follow hub.toml's [flow] repos.

ALTER TABLE repositories ADD COLUMN flow TEXT NOT NULL DEFAULT '';

    /// OxygenFlow: `on`, `off`, or empty to follow hub.toml (migration 0018).

    #[sqlx(default)]

    pub flow: String,

}

/// `on`, `off`, or `` (follow hub.toml's `[flow] repos`).

pub async fn set_flow(pool: &Pool, id: i64, setting: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE repositories SET flow = ? WHERE id = ?").bind(setting).bind(id).execute(pool).await?;

    Ok(())

/// Whether pushes to this repository start runs: its own setting when a

/// site administrator made one, else hub.toml's `[flow] repos`.

pub fn enabled(app: &Shared, row: &db::repos::RepoRow) -> bool {

    match row.flow.as_str() {

        "on" => true,

        "off" => false,

        _ => app.config.flow.allows(&row.owner, &row.name),

    }

}

    if bookmark.starts_with("tags/") || heads.is_empty() || !enabled(app, row) {

    let enabled = crate::flow::enabled(&app, &row);

        .route("/{owner}/{name}/settings/flow", post(repo_settings::flow))

    /// Whether hub.toml alone would run Flow here, and whether it runs.

    flow_default: bool,

    flow_enabled: bool,

    site_admin: bool,

    let flow_default = app.config.flow.allows(&row.owner, &row.name);

    let flow_enabled = crate::flow::enabled(app, &row);

    let site_admin = shell.is_admin;

    Ok(Page(RepoSettingsPage {

        shell,

        repo,

        row,

        collaborators,

        teams,

        role,

        requirements,

        hooks,

        required_checks,

        flow_default,

        flow_enabled,

        site_admin,

        notice,

        error,

    }))

}

#[derive(Deserialize)]

pub struct FlowForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// `on`, `off`, or `default`.

    flow: String,

}

/// Turn OxygenFlow on or off for one repository. Runs use the site's

/// runners, so only site administrators decide.

pub async fn flow(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<FlowForm>,

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

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

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

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

    if !viewer.is_admin() {

        return settings_page(&app, shell, row, role, None, Some("Only site administrators turn OxygenFlow on or off.".into())).await;

    }

    let setting = match f.flow.as_str() {

        "on" => "on",

        "off" => "off",

        "default" => "",

        _ => return settings_page(&app, shell, row, role, None, Some("Pick on, off or the site default.".into())).await,

    };

    db::repos::set_flow(&app.db, row.id, setting).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let label = if setting.is_empty() { "default" } else { setting };

    accounts::audit(&app.db, viewer.account(), "repo.flow", &format!("{owner}/{name}"), label).await.ok();

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);

    let notice = if crate::flow::enabled(&app, &row) {

        "OxygenFlow is on: pushes with a .flow/pipeline.kdl start runs."

    } else {

        "OxygenFlow is off for this repository."

    };

    settings_page(&app, shell, row, role, Some(notice.into()), None).await

/// OxygenFlow per repository: site administrators turn it on or off in

/// the repository's settings; hub.toml's `[flow] repos` is the default.

#[tokio::test(flavor = "multi_thread")]

async fn flow_is_switched_per_repository_by_site_admins() {

    let h = hub().await;

    let app = &h.app;

    let andy = call(app, "POST", "/register", None, None, None, Some("username=andy&email=a%40example.com&password=correct-horse-battery"))

        .await

        .cookie

        .unwrap();

    let page = call(app, "GET", "/new", None, Some(&andy), None, None).await;

    call(app, "POST", "/new", None, Some(&andy), None, Some(&format!("_csrf={}&owner=andy&name=demo", csrf_of(&page.body)))).await;

    let row = || async { oxygenhub::db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap() };

    assert!(!oxygenhub::flow::enabled(app, &row().await), "not in [flow] repos");

    let tab = call(app, "GET", "/andy/demo/flow", None, Some(&andy), None, None).await;

    assert!(tab.body.contains("not enabled") && tab.body.contains("/andy/demo/settings#flow"));

    let set = |value: &'static str| {

        let (app, andy) = (app.clone(), andy.clone());

        async move {

            let settings = call(&app, "GET", "/andy/demo/settings", None, Some(&andy), None, None).await;

            call(

                &app,

                "POST",

                "/andy/demo/settings/flow",

                None,

                Some(&andy),

                None,

                Some(&format!("_csrf={}&flow={value}", csrf_of(&settings.body))),

            )

            .await

        }

    };

    // A repository admin who is not a site admin sees the state but cannot change it.

    let id = oxygenhub::db::accounts::account_by_name(&app.db, "andy").await.unwrap().unwrap().id;

    oxygenhub::db::accounts::set_admin(&app.db, id, false).await.unwrap();

    let settings = call(app, "GET", "/andy/demo/settings", None, Some(&andy), None, None).await;

    assert!(settings.body.contains("do not start runs") && !settings.body.contains("name=\"flow\""));

    let r = set("on").await;

    assert!(r.body.contains("Only site administrators"), "{}", r.body);

    assert_eq!(row().await.flow, "");

    oxygenhub::db::accounts::set_admin(&app.db, id, true).await.unwrap();

    let r = set("on").await;

    assert!(r.body.contains("OxygenFlow is on"), "{}", r.body);

    assert_eq!(row().await.flow, "on");

    assert!(oxygenhub::flow::enabled(app, &row().await));

    assert!(!call(app, "GET", "/andy/demo/flow", None, Some(&andy), None, None).await.body.contains("not enabled"));

    set("off").await;

    assert!(!oxygenhub::flow::enabled(app, &row().await));

    set("default").await;

    assert_eq!(row().await.flow, "");

    assert!(set("sometimes").await.body.contains("Pick on, off"));

}

/// A repository's own Flow setting overrides hub.toml either way.

#[tokio::test(flavor = "multi_thread")]

async fn a_repository_setting_turns_flow_on_or_off() {

    let h = hub().await;

    create(&h.app, "other", "plain").await;

    create(&h.app, "andy", "quiet").await;

    let row = db::repos::get(&h.app.db, "other", "plain").await.unwrap().unwrap();

    db::repos::set_flow(&h.app.db, row.id, "on").await.unwrap();

    let quiet = db::repos::get(&h.app.db, "andy", "quiet").await.unwrap().unwrap();

    db::repos::set_flow(&h.app.db, quiet.id, "off").await.unwrap();

    for (owner, name) in [("other", "plain"), ("andy", "quiet")] {

        let work = tempfile::tempdir().unwrap();

        let c = client(&format!("{}/{owner}/{name}", h.base), work.path());

        write(work.path(), ".flow/pipeline.kdl", &pipeline(""));

        write(work.path(), "test.sh", "echo ok\n");

        c.commit("Add a pipeline", &[]).unwrap();

        assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    }

    assert_eq!(runs_of(&h.app, "other", "plain").await.len(), 1, "turned on");

    assert!(runs_of(&h.app, "andy", "quiet").await.is_empty(), "turned off despite andy/*");

}

- **Configuration.** `[flow] runner_tokens` (bearer tokens for runners, compared in constant time), `repos` (patterns such as `owner/*` or `owner/name`: the repositories whose pushes start runs by default; empty means none) and `job_timeout_minutes` (60).

- **Per repository.** A site administrator turns OxygenFlow on or off for one repository under Settings → OxygenFlow, which overrides `repos` in either direction; "site default" follows it again. Runs use the site's runners, so repository administrators see the setting but cannot change it. Changes are audited (`repo.flow`) and apply from the next push, with no restart.

  <p>OxygenFlow is not enabled for this repository. A site administrator turns it on under <a href="{{ repo.url }}/settings#flow">Settings → OxygenFlow</a>.</p>

  <a href="#flow">OxygenFlow</a>

</form>

<form class="card wide" id="flow" method="post" action="{{ repo.url }}/settings/flow">

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

  <h2>OxygenFlow</h2>

  <p>Pushes to this repository {% if flow_enabled %}<strong>start runs</strong>{% else %}<strong>do not start runs</strong>{% endif %} of its <code>.flow/pipeline.kdl</code>.</p>

  {% if site_admin %}

  <div class="choice">

    <label><input type="radio" name="flow" value="on"{% if row.flow == "on" %} checked{% endif %}> on</label>

    <label><input type="radio" name="flow" value="off"{% if row.flow == "off" %} checked{% endif %}> off</label>

    <label><input type="radio" name="flow" value="default"{% if row.flow.is_empty() %} checked{% endif %}> site default ({% if flow_default %}on{% else %}off{% endif %}, from <code>[flow] repos</code> in <code>hub.toml</code>)</label>

  </div>

  <p class="small mute">Runs use the site's runners, so only site administrators change this. It takes effect at the next push.</p>

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

  {% else %}

  <p class="small mute">A site administrator turns OxygenFlow on or off here.</p>

  {% endif %}