Run pipeline from bookmarks and changes, and say why it is unavailable 4f6925337848

    /// A change's full hash: run the state whose only head it is, instead

    /// of a bookmark's.

    #[serde(default)]

    change: Option<String>,

/// state, or one change's, without moving anything (hub spec §13.2).

    let (n, what) = match body.change.filter(|c| !c.trim().is_empty()) {

        Some(change) => {

            let n = crate::flow::run_change(&app, &row, &change, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?;

            (n, format!("change {}", change.trim()))

        }

        None => {

            let bookmark = body.bookmark.unwrap_or_else(|| row.default_bookmark.clone());

            (crate::flow::run_bookmark(&app, &row, &bookmark, &me.username).await.map_err(|m| ApiError(StatusCode::CONFLICT, m))?, bookmark)

        }

    };

    db::accounts::audit(&app.db, Some(&me), "flow.run", &format!("{owner}/{name}"), &format!("#{n} {what}")).await.ok();

/// "Run pipeline" on one committed change: the state whose only head is

/// `change`, whatever bookmarks hold it. Returns the new run's number.

pub async fn run_change(app: &Shared, row: &db::repos::RepoRow, change: &str, actor: &str) -> Result<i64, String> {

    if !enabled(app, row) {

        return Err("OxygenFlow is not enabled for this repository".into());

    }

    let h = ChangeHash::from_hex(change.trim().trim_start_matches('#')).ok_or("give the full hash of a change")?;

    let repo = RepoName::new(&row.owner, &row.name).ok_or("bad repository name")?;

    let known = app.repos.read(&repo, move |r, _| Ok(r.store().get_change(&h).is_ok())).await.map_err(|e| e.to_string())?;

    if !known {

        return Err(format!("no change {} in this repository", &change.trim()[..12.min(change.trim().len())]));

    }

    let state = oxy_core::hash::hash_object(oxy_core::hash::ObjectType::State, &oxy_core::objects::StateObject::new(vec![h]).encode());

    start_run(app, row, "", &state.to_hex(), &[h], actor, "manual")

        .await?

        .ok_or_else(|| format!("that change's state has no {PIPELINE_PATH}"))

}

    /// Why this viewer is not offered "Run pipeline", when they are not.

    why_not: Option<String>,

/// Why `viewer` may not start runs here, or `None` when they may.

pub fn why_not_run(enabled: bool, signed_in: bool, role: Role) -> Option<String> {

    if !enabled {

        Some("Flow is off for this repository; a site administrator can turn it on in Settings → Flow.".into())

    } else if !signed_in {

        Some("Sign in with write access to run the pipeline.".into())

    } else if role < Role::Write {

        Some("Running the pipeline needs write access to this repository.".into())

    } else {

        None

    }

}

    let why_not = why_not_run(enabled, viewer.account().is_some(), role);

    let can_run = why_not.is_none();

        why_not,

    #[serde(default)]

    /// A change's full hash: run the state whose only head it is.

    #[serde(default)]

    change: String,

/// `POST /{owner}/{name}/flow/start`: "Run pipeline" on a bookmark's

/// current state, or on one committed change.

    let (started, what) = if f.change.trim().is_empty() {

        (crate::flow::run_bookmark(&app, &row, f.bookmark.trim(), &me.account.username).await, f.bookmark.trim().to_string())

    } else {

        (crate::flow::run_change(&app, &row, &f.change, &me.account.username).await, format!("change {}", f.change.trim()))

    };

    Ok(match started {

            db::accounts::audit(&app.db, Some(&me.account), "flow.run", &format!("{owner}/{name}"), &format!("#{n} {what}")).await.ok();

    /// Whether the viewer may run the pipeline on this change.

    can_run: bool,

    let can_run = super::flow::why_not_run(crate::flow::enabled(&app, &row), viewer.account().is_some(), role).is_none();

    Ok(Page(ChangePage {

        shell,

        repo: RepoShell::new(&app, &row, "changes").with_role(role),

        c,

        files,

        body_html,

        ignore_ws,

        receipts,

        can_run,

    }))

    /// Whether the viewer may run the pipeline of a bookmark.

    can_run: bool,

    let can_run = super::flow::why_not_run(crate::flow::enabled(app, &row), shell.user.is_some(), role).is_none();

    Ok(Page(BookmarksPage {

        shell,

        repo: RepoShell::new(app, &row, "bookmarks").with_role(role),

        bookmarks,

        can_delete,

        can_run,

        notice,

        error,

    }))

    // Run pipeline on one change: its state, with no bookmark.

    let head = first[0].head_list()[0].to_string();

    let (st, body) =

        call(&h.app, "POST", "/api/v1/repos/andy/demo/flow/runs", Some("site"), Some(format!(r#"{{"change":"{head}"}}"#))).await;

    assert_eq!(st, StatusCode::CREATED, "{body}");

    let on_change = db::flow::run(&h.app.db, first[0].repo_id, 3).await.unwrap().unwrap();

    assert_eq!(

        (on_change.bookmark.as_str(), on_change.heads.as_str(), on_change.state.as_str()),

        ("", head.as_str(), first[0].state.as_str())

    );

    let (_, page) = call(&h.app, "GET", "/andy/demo/flow/3", None, None).await;

    assert!(page.contains("title=\"Run on one change, not a bookmark\">change</span>"), "run page");

    let (st, body) =

        call(&h.app, "POST", "/api/v1/repos/andy/demo/flow/runs", Some("site"), Some(format!(r#"{{"change":"{}"}}"#, "ab".repeat(32))))

            .await;

    assert!(st == StatusCode::CONFLICT && body.contains("no change"), "{st} {body}");

    // Viewers who cannot start runs are told why, and get no button.

    let (_, page) = call(&h.app, "GET", "/andy/demo/flow", None, None).await;

    assert!(page.contains("Sign in with write access to run the pipeline.") && !page.contains("primary-btn"));

    let (_, page) = call(&h.app, "GET", "/andy/demo/bookmarks", None, None).await;

    assert!(!page.contains("/flow/start"), "no run buttons for anonymous viewers");

    let third = db::flow::run(&h.app.db, row.id, 4).await.unwrap().unwrap();

        checks.iter().all(|c| c.status == "queued" && c.url.ends_with("/flow/4")),

    let (_, page) = call(&h.app, "GET", "/andy/demo/flow/4", None, None).await;

    let (_, page) = call(&h.app, "GET", "/andy/demo/flow", None, None).await;

    assert!(page.contains("Flow is off for this repository"), "and the Flow tab says so");

- **Triggers.** A push that moves a bookmark of an allowed repository starts a **run** on the bookmark's new state, numbered within its repository from 1 (the run's page is `/{owner}/{name}/flow/{number}`): the hub reads `.flow/pipeline.kdl` from that state and validates it with `flow-core` (the same code `flow check` runs). An invalid pipeline records a run in `error` with the problems and their lines; a state without a pipeline records nothing. Tags and proposals start no runs yet, so only code from people with write access ever runs. A run waiting for a runner says where it stands: on the Flow tab its place in line, on its page also the jobs running now and those queued ahead of it (named when their repository is this one or public, otherwise counted), and in the API `queue_position`. Writers also start runs without moving a bookmark: **Run pipeline** runs a committed state without a push:

  - On the Flow tab and beside each bookmark on the bookmarks page, it runs a bookmark's current state.

  - On a change page, it runs the state whose only head is that change. That run has no bookmark and is labelled "change".

  - The API does the same with `POST /flow/runs` and `{"bookmark"}` or `{"change"}`.

  Viewers who may not start runs get no button. The Flow tab says why: Flow is off for the repository, they are not signed in, or they lack write access. **Re-run** on a finished run's page runs its state again.

  Runs only ever take committed states already in the repository, never uncommitted work. A run writes no history: its receipts are signed statements about a state (Oxygen spec §14.6). Running a state again adds another statement. The environment hash shows whether it ran in the same environment, and a matching result is independent confirmation. The new run's checks replace the old ones for that state, and the run page says what started it (pushed by, started by, re-run of #N by).

  <td class="small">{% if can_run %}<form class="inline" method="post" action="{{ repo.url }}/flow/start"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="bookmark" value="{{ b.name }}"><button type="submit" class="small" title="Run the pipeline of {{ b.name }}'s current state">Run pipeline</button></form> · {% endif %}<a href="{{ repo.url }}/changes/{{ b.name }}">history</a>{% if !b.default %} · <a href="{{ repo.url }}/compare/{{ repo.default_bookmark }}...{{ b.name }}">compare with {{ repo.default_bookmark }}</a>{% if can_delete %}

  <p class="small"><a href="{{ repo.url }}/tree/{{ c.view.hash }}">Browse the tree at this change</a>{% if can_run %} · <form class="inline" method="post" action="{{ repo.url }}/flow/start"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><input type="hidden" name="change" value="{{ c.view.hash }}"><button type="submit" class="small" title="Run the pipeline on the state whose only head is this change">Run pipeline on this change</button></form>{% endif %}</p>

  <p class="small mute">{% if run.bookmark.is_empty() %}<span class="tag" title="Run on one change, not a bookmark">change</span>{% else %}<span class="lbl lbl-bm">{{ run.bookmark }}</span>{% endif %} at <a href="{{ repo.url }}/tree/{{ run.heads }}" title="state {{ run.state }}"><code>{{ run.state|short }}</code></a> · {{ run.started_by() }} <time title="{{ run.created_ms|when_i }}">{{ run.created_ms|ago_i }}</time> · {{ duration }}{% if !run.pipeline_hash.is_empty() %} · pipeline <code title="{{ run.pipeline_hash }}">{{ run.pipeline_hash|short }}</code>{% endif %} · <a href="{{ repo.url }}/file/{{ run.heads }}/.flow/pipeline.kdl">.flow/pipeline.kdl</a> · <a href="{{ repo.url }}/flow">all runs</a></p>

{% if can_run %}<form class="inline" method="post" action="{{ repo.url }}/flow/start"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><label for="run-bookmark" class="small mute">Run the pipeline of</label> <select id="run-bookmark" name="bookmark">{% for b in bookmarks %}<option value="{{ b }}">{{ b }}</option>{% endfor %}</select> <button type="submit" class="primary-btn">Run pipeline</button></form>{% endif %}

{% if let Some(w) = why_not %}<p class="small mute">{{ w }}</p>{% endif %}

  <p>No runs yet. Add <code>.flow/pipeline.kdl</code> to a bookmark and push: every push that moves a bookmark runs it in OxygenFlow microVMs. Once it is there, <strong>Run pipeline</strong> above runs a bookmark's current state without a push, as does the button beside each bookmark and on each change.</p>

    <td>{% if row.r.bookmark.is_empty() %}<span class="tag" title="Run on one change, not a bookmark">change</span>{% else %}<span class="lbl lbl-bm">{{ row.r.bookmark }}</span>{% endif %}</td>

button.primary-btn { background: var(--acc); color: var(--now-ink); }

button.primary-btn:hover { filter: brightness(1.1); }