Land when checks pass 86a69b53aff0

-- Land when checks pass (oxygenhub#261): who set it (empty: off) and when.

ALTER TABLE proposals ADD COLUMN auto_land_by TEXT NOT NULL DEFAULT '';

ALTER TABLE proposals ADD COLUMN auto_land_ms BIGINT;

-- Land when checks pass (oxygenhub#261): who set it (empty: off) and when.

ALTER TABLE proposals ADD COLUMN auto_land_by TEXT NOT NULL DEFAULT '';

ALTER TABLE proposals ADD COLUMN auto_land_ms INTEGER;

//! Land when checks pass (oxygenhub#261): someone who may land a proposal

//! sets it, and the hub lands it, as them, once its required checks pass

//! on its projected state and nothing else blocks it. A push to the source

//! makes a new projected state whose checks run again, so it waits again;

//! a required check that fails turns it off, with a note on the timeline;

//! so does the setter losing the right to land. Anyone who may land can

//! turn it off.

use crate::auth::roles::{self, Access};

use crate::db::{self, accounts, proposals as pdb};

use crate::repos::RepoName;

use crate::Shared;

/// One evaluation at a time across the hub: two checks finishing together

/// must not land a proposal twice.

static TURN: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());

/// Check statuses that end a check without its passing.

const FAILED: [&str; 2] = ["failed", "cancelled"];

/// Turn it on (`by`, who may land) or off, and look at once: a proposal

/// whose checks have already passed lands now.

pub async fn set(app: &Shared, row: &db::repos::RepoRow, p: &pdb::ProposalRow, by: &accounts::Account, on: bool) -> sqlx::Result<()> {

    if on {

        pdb::set_auto_land(&app.db, p.id, &by.username).await?;

        pdb::add_event(&app.db, p.id, &by.username, "set it to land when its checks pass", "").await.ok();

        accounts::audit(&app.db, Some(by), "proposal.auto_land", &format!("{}/{}#{}", row.owner, row.name, p.number), "on").await.ok();

        let p = pdb::get(&app.db, row.id, p.number).await?.unwrap_or_else(|| p.clone());

        evaluate(app, row, p).await;

    } else if !p.auto_land_by.is_empty() {

        pdb::set_auto_land(&app.db, p.id, "").await?;

        pdb::add_event(&app.db, p.id, &by.username, "turned off landing when its checks pass", "").await.ok();

        accounts::audit(&app.db, Some(by), "proposal.auto_land", &format!("{}/{}#{}", row.owner, row.name, p.number), "off").await.ok();

    }

    Ok(())

}

/// A check was recorded on `state`: the proposals set to land on it are

/// looked at again.

pub async fn on_check(app: &Shared, row: &db::repos::RepoRow, state: &str) {

    let waiting = match pdb::auto_landing(&app.db, row.id, state).await {

        Ok(w) => w,

        Err(e) => {

            tracing::warn!("auto-land: {e}");

            return;

        }

    };

    for p in waiting {

        evaluate(app, row, p).await;

    }

}

/// [`on_check`] as a boxed task, for `hooks::emit` to spawn: landing emits

/// hooks itself, so the future's type would otherwise contain itself.

pub fn on_check_task(

    app: Shared,

    row: db::repos::RepoRow,

    state: String,

) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send>> {

    Box::pin(async move { on_check(&app, &row, &state).await })

}

async fn off(app: &Shared, p: &pdb::ProposalRow, why: &str) {

    pdb::set_auto_land(&app.db, p.id, "").await.ok();

    pdb::add_event(&app.db, p.id, "oxygenhub", "turned off landing when its checks pass", why).await.ok();

}

/// Land it if its checks have passed and nothing else blocks it; turn it

/// off if a required check failed or its setter may no longer land; else

/// wait.

async fn evaluate(app: &Shared, row: &db::repos::RepoRow, p: pdb::ProposalRow) {

    let _turn = TURN.lock().await;

    // Landed or closed meanwhile, or turned off.

    let Ok(Some(p)) = pdb::get(&app.db, row.id, p.number).await else { return };

    if !p.is_open() || p.auto_land_by.is_empty() {

        return;

    }

    let setter = match accounts::account_by_name(&app.db, &p.auto_land_by).await {

        Ok(Some(a)) if !a.blocked() => a,

        _ => return off(app, &p, &format!("{} can no longer land it", p.auto_land_by)).await,

    };

    let role = roles::role_for(&app.db, Some(&setter), row).await.ok().flatten();

    if !roles::allows(role, Access::Write) {

        return off(app, &p, &format!("{} can no longer land it", setter.username)).await;

    }

    let Some(repo) = RepoName::new(&row.owner, &row.name) else { return };

    let number = p.number;

    let Ok(loaded) = crate::web::proposals::load(app, &repo, p.clone()).await else { return };

    let required = db::hooks::required_checks(&app.db, row.id).await.unwrap_or_default();

    let checks = db::hooks::checks_for_state(&app.db, row.id, &loaded.state).await.unwrap_or_default();

    let failed: Vec<&str> = required

        .iter()

        .filter(|n| checks.iter().any(|c| &c.name == *n && FAILED.contains(&c.status.as_str())))

        .map(|n| n.as_str())

        .collect();

    if !failed.is_empty() {

        let why = format!("{} did not pass", failed.join(", "));

        return off(app, &p, &why).await;

    }

    let Ok(v) = crate::web::proposals::verdict(app, &loaded, row.id).await else { return };

    if !v.blockers.is_empty() {

        return;

    }

    let via = format!("when its checks passed (set by {})", setter.username);

    match crate::web::proposals::land_as(app, &repo, row, &setter, number, &via, false, None).await {

        Ok(_) => {

            pdb::set_auto_land(&app.db, p.id, "").await.ok();

        }

        Err(crate::web::proposals::Landing::Refused(why)) => off(app, &p, &why).await,

        Err(crate::web::proposals::Landing::NotFound) => {}

    }

}

    /// Who set it to land when its checks pass (oxygenhub#261), while set.

    #[serde(default)]

    pub auto_land: Option<String>,

        .route("/repos/{owner}/{name}/proposals/{number}/auto-land", post(auto_land_on).delete(auto_land_off))

/// `POST /repos/{o}/{n}/proposals/{number}/auto-land` (repo:write, #261):

/// land it when its checks pass; at once if they already have.

async fn auto_land_on(

    State(app): State<Shared>,

    headers: HeaderMap,

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

) -> Result<Json<Proposal>, ApiError> {

    auto_land_set(&app, &headers, &owner, &name, number, true).await?;

    proposal(State(app), headers, Path((owner, name, number))).await

}

/// `DELETE …/auto-land`: it will not land by itself.

async fn auto_land_off(

    State(app): State<Shared>,

    headers: HeaderMap,

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

) -> Result<Json<Proposal>, ApiError> {

    auto_land_set(&app, &headers, &owner, &name, number, false).await?;

    proposal(State(app), headers, Path((owner, name, number))).await

}

async fn auto_land_set(app: &Shared, headers: &HeaderMap, owner: &str, name: &str, number: i64, on: bool) -> Result<(), ApiError> {

    let c = caller(app, headers).await?;

    let me = c.require("repo:write")?.clone();

    let (_, row, _) = reach(app, &c, owner, name, Access::Write).await?;

    let p = db::proposals::get(&app.db, row.id, number).await?.ok_or_else(|| not_found("no such proposal"))?;

    if !p.is_open() {

        return Err(ApiError(StatusCode::CONFLICT, format!("the proposal is {}", p.state)));

    }

    crate::autoland::set(app, &row, &p, &me, on).await?;

    Ok(())

}

    /// Who set it to land when its checks pass (#261); empty when off.

    #[sqlx(default)]

    pub auto_land_by: String,

    #[sqlx(default)]

    pub auto_land_ms: Option<i64>,

    .fetch_all(pool)

    .await

}

/// Set, or with `by` empty clear, landing when checks pass (#261).

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

    sqlx::query("UPDATE proposals SET auto_land_by = $1, auto_land_ms = $2 WHERE id = $3")

        .bind(by)

        .bind((!by.is_empty()).then(now_ms))

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

/// A repository's open proposals set to land when their checks pass, on

/// projected state `state`.

pub async fn auto_landing(pool: &Pool, repo_id: i64, state: &str) -> sqlx::Result<Vec<ProposalRow>> {

    sqlx::query_as(

        "SELECT * FROM proposals WHERE repo_id = $1 AND state = 'open' AND auto_land_by != '' AND projected_state = $2 ORDER BY number",

    )

    .bind(repo_id)

    .bind(state)

    // A check on a state may let a proposal set to land when its checks

    // pass land now (#261): every check is announced here.

    if event == "check" {

        if let Some(state) = data["check"]["state"].as_str() {

            let (app, repo, state) = (app.clone(), repo.clone(), state.to_string());

            tokio::spawn(crate::autoland::on_check_task(app, repo, state));

        }

    }

pub mod autoland;

        .route("/{owner}/{name}/proposal/{number}/auto-land", post(proposals::auto_land))

    can_auto_land: bool,

    // Not landable yet: anyone who may land can set it to land when its

    // checks pass (#261).

    let can_auto_land = role >= Role::Write && p.is_open() && !v.blockers.is_empty();

        can_auto_land,

#[derive(serde::Deserialize)]

pub struct AutoLandForm {

    #[serde(rename = "_csrf")]

    csrf: String,

    /// `1` to set it, else off.

    #[serde(default)]

    on: String,

}

/// `POST …/proposal/{n}/auto-land` (#261): land when its checks pass, set

/// or cleared by someone who may land it.

pub async fn auto_land(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<AutoLandForm>,

) -> Result<Response, Error> {

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

    let me = require(&viewer, &shell)?;

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

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

    let p = pdb::get(&app.db, row.id, number)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?

        .filter(|p| p.is_open())

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let on = f.on == "1";

    crate::autoland::set(&app, &row, &p, &me.account, on).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let note = if on { "It will land when its checks pass." } else { "It will not land by itself." };

    Ok(back(&owner, &name, number, "conversation", Some(note.into()), None))

}

        auto_land: (p.is_open() && !p.auto_land_by.is_empty()).then(|| p.auto_land_by.clone()),

/// Land when checks pass (#261): set by someone who may land, it lands as

/// them once the required check passes on the projected state; a failing

/// check turns it off, with a note; it can be turned off.

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

async fn a_proposal_lands_itself_when_its_checks_pass() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let repo = RepoName::parse("andy/demo").unwrap();

    app.repos.create(&repo, None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "", hub_api::Visibility::Public).await.unwrap();

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

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

    let mut client = Repo::init(work.path()).unwrap();

    client.create_identity("Andy McCall", "[email protected]", oxy_core::repo::IdentityScope::User).unwrap();

    client.config.set("remote.origin.url", &format!("{}/andy/demo", h.base)).unwrap();

    client.config.set("remote.origin.token", "site").unwrap();

    client.save_config().unwrap();

    write(work.path(), "a.txt", b"one\n");

    client.snapshot("t").unwrap();

    let base = client.commit("base", &[]).unwrap();

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

    for (bm, file) in [("one", "b.txt"), ("two", "c.txt")] {

        client.bookmark_create(bm, Some(&[base])).unwrap();

        client.bookmark_switch(bm, false).unwrap();

        write(work.path(), file, b"x\n");

        client.snapshot("t").unwrap();

        client.commit(&format!("on {bm}"), &[]).unwrap();

        assert!(client.push_bookmark("origin", bm, false).unwrap().iter().all(|r| r.ok));

        let preview = get(app, &format!("/andy/demo/proposals/new?source={bm}&target=main"), Some(&andy)).await;

        let r = post(

            app,

            "/andy/demo/proposals/new",

            Some(&andy),

            &format!("_csrf={}&title={bm}&body=&target=main&source={bm}", csrf_of(&preview.body)),

        )

        .await;

        assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    }

    db::hooks::set_required_checks(&app.db, row.id, &["flow/test".to_string()]).await.unwrap();

    let check = |number: i64, status: &'static str| async move {

        let p = db::proposals::get(&app.db, row.id, number).await.unwrap().unwrap();

        let report =

            db::hooks::CheckReport { state: &p.projected_state, name: "flow/test", status, summary: "", url: "", reporter: None, seal: "" };

        db::hooks::upsert_check(&app.db, row.id, report).await.unwrap();

        oxygenhub::hooks::emit(app, row, "check", "flow", serde_json::json!({ "check": { "state": p.projected_state } })).await;

    };

    let state_of = |number: i64| async move {

        for _ in 0..100 {

            let p = db::proposals::get(&app.db, row.id, number).await.unwrap().unwrap();

            if p.state != "open" || p.auto_land_by.is_empty() {

                return p;

            }

            tokio::time::sleep(std::time::Duration::from_millis(50)).await;

        }

        db::proposals::get(&app.db, row.id, number).await.unwrap().unwrap()

    };

    // #1: set while its check is pending; it waits, then lands as Andy.

    let page = get(app, "/andy/demo/proposal/1", Some(&andy)).await;

    assert!(page.body.contains("LAND WHEN CHECKS PASS"), "{}", page.body);

    let r = act(app, "/andy/demo/proposal/1/auto-land", Some(&andy), &format!("_csrf={}&on=1", csrf_of(&page.body))).await;

    assert!(r.body.contains("lands when its checks pass (set by"), "{}", r.body);

    assert_eq!(db::proposals::get(&app.db, row.id, 1).await.unwrap().unwrap().state, "open", "the check has not passed");

    check(1, "running").await;

    tokio::time::sleep(std::time::Duration::from_millis(200)).await;

    assert_eq!(db::proposals::get(&app.db, row.id, 1).await.unwrap().unwrap().state, "open", "still running");

    check(1, "passed").await;

    let p = state_of(1).await;

    assert_eq!((p.state.as_str(), p.landed_by.as_str()), ("landed", "andy"));

    assert!(p.landed_via.contains("when its checks passed (set by andy)"), "{}", p.landed_via);

    // #2: a failing check turns it off, with a note; it stays open.

    let page = get(app, "/andy/demo/proposal/2", Some(&andy)).await;

    act(app, "/andy/demo/proposal/2/auto-land", Some(&andy), &format!("_csrf={}&on=1", csrf_of(&page.body))).await;

    check(2, "failed").await;

    let p = state_of(2).await;

    assert_eq!((p.state.as_str(), p.auto_land_by.as_str()), ("open", ""));

    let page = get(app, "/andy/demo/proposal/2", Some(&andy)).await;

    assert!(page.body.contains("turned off landing when its checks pass") && page.body.contains("flow/test did not pass"), "{}", page.body);

    // Set again and turned off by hand.

    act(app, "/andy/demo/proposal/2/auto-land", Some(&andy), &format!("_csrf={}&on=1", csrf_of(&page.body))).await;

    let page = get(app, "/andy/demo/proposal/2", Some(&andy)).await;

    let r = act(app, "/andy/demo/proposal/2/auto-land", Some(&andy), &format!("_csrf={}&on=0", csrf_of(&page.body))).await;

    assert!(r.body.contains("will not land by itself"), "{}", r.body);

    assert!(db::proposals::get(&app.db, row.id, 2).await.unwrap().unwrap().auto_land_by.is_empty());

}

        #[arg(long, value_name = "REASON", conflicts_with = "when_ready")]

        /// Land it by itself once its checks pass (#261); with --off, don't

        #[arg(long)]

        when_ready: bool,

        /// With --when-ready: turn it off

        #[arg(long, requires = "when_ready")]

        off: bool,

        }

        ProposalCmd::Land { number, when_ready: true, off, .. } => {

            let path = format!("{base}/proposals/{number}/auto-land");

            let p: Proposal =

                if off { c.send("DELETE", &path, &serde_json::json!({}))? } else { c.send("POST", &path, &serde_json::json!({}))? };

            if json {

                println!("{}", serde_json::to_string(&p)?);

            } else if p.landed.is_some() {

                println!("{} landed #{} on {}: its checks had passed", ui::ok("✔"), p.number, p.target);

            } else if p.auto_land.is_some() {

                println!("{} #{} will land when its checks pass", ui::ok("✔"), p.number);

            } else {

                println!("{} #{} will not land by itself", ui::ok("✔"), p.number);

            }

        ProposalCmd::Land { number, over_checks, .. } => {

**Land when checks pass** (oxygenhub#261). Anyone who may land a proposal can set it to land by itself: *Land when checks pass* on the proposal, `POST /repos/{owner}/{name}/proposals/{n}/auto-land` (`DELETE` turns it off), or `oh proposal land N --when-ready` (`--off`). Whenever a check is recorded on a state, the open proposals set to land on that projected state are looked at: once every required check has passed and nothing else blocks it, it lands as the person who set it ("when its checks passed (set by NAME)"), if they may still land; a required check that fails or is cancelled turns it off, with a note on the timeline; a push to the source makes a new projected state whose checks run, so it waits again. It shows on the proposal ("lands when its checks pass (set by NAME)") and in the API (`auto_land`); setting and clearing it are on the timeline and audited (`proposal.auto_land`). Migration 0081 (`proposals.auto_land_by`, `auto_land_ms`).

    {% if !p.auto_land_by.is_empty() %}<p class="small"><span class="sig sig-pending" aria-hidden="true">◷</span> lands when its checks pass (set by <a href="/{{ p.auto_land_by }}">{{ p.auto_land_by }}</a>)</p>

      {% if can_auto_land %}<form method="post" action="{{ repo.url }}/proposal/{{ p.number }}/auto-land"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="on" value="0"><button type="submit" class="small">don't land it by itself</button></form>{% endif %}

    {% else if can_auto_land && hub_can_land %}<form method="post" action="{{ repo.url }}/proposal/{{ p.number }}/auto-land"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="on" value="1"><button type="submit" title="It lands, as you, once its required checks pass and nothing else blocks it">LAND WHEN CHECKS PASS</button></form>{% endif %}