Flow on your own runners 1870e4fa9808

- **Flow on your own runners (#225):** a repository's maintainers can turn OxygenFlow on for it themselves once it (or its owner) has a runner of its own: Settings › OxygenFlow › "on, own runners only". Its jobs then go only to those runners, never to the site's; letting the site's runners take them stays a site administrator's choice.

         AND NOT (? = '' AND ? IS NULL AND rep.flow = 'own') \

    // A repository on its own runners only (#225): the site's runners skip it.

    .bind(&scope.owner)

    .bind(scope.repo_id)

        // `own`: on, run only by the repository's or its owner's runners (#225).

        "on" | "own" => true,

    /// Whether the repository or its owner has a runner of its own (#225).

    own_runner: bool,

    let own_runner = has_own_runner(app, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        own_runner,

/// Turn OxygenFlow on or off for one repository. Site administrators choose

/// anything; the repository's maintainers may turn it on on their own

/// runners (`own`), when the repository or its owner has one, or off (#225).

/// Only site administrators let the site's runners take its jobs.

        "own" => "own",

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

    if !viewer.is_admin() {

        if matches!(setting, "on" | "") {

            return settings_page(

                &app,

                shell,

                row,

                role,

                None,

                Some("Only site administrators let the site's runners take this repository's jobs.".into()),

            )

            .await;

        }

        if setting == "own" && !has_own_runner(&app, &row).await.map_err(|e| Error::from_db(shell.clone(), e))? {

            return settings_page(

                &app,

                shell,

                row,

                role,

                None,

                Some("Register a runner for this repository (Runners, below) or its owner first.".into()),

            )

            .await;

        }

    }

    let notice = if row.flow == "own" {

        "OxygenFlow is on, on this repository's own runners: pushes with a .flow/pipeline.kdl start runs that only they take."

    } else if crate::flow::enabled(&app, &row) {

}

/// Whether a runner serves this repository that is not the site's: one

/// scoped to it or to its owner (#225).

async fn has_own_runner(app: &Shared, row: &db::repos::RepoRow) -> sqlx::Result<bool> {

    Ok(db::runners::serving(&app.db, &row.owner, row.id).await?.iter().any(|r| !r.scope().is_site()))

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

/// #225: an ordinary user turns Flow on for their repository on their own

/// runner, and the site's runners never take its jobs.

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

async fn owners_run_flow_on_their_own_runners_only() {

    use oxy_core::identity::SecretKey;

    let h = hub().await;

    let register = |name: &'static str| {

        let app = h.app.clone();

        async move {

            let body = format!("username={name}&email={name}%40example.com&password=correct-horse-battery");

            let res = oxygenhub::router(app)

                .oneshot(

                    Request::post("/register")

                        .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded")

                        .body(Body::from(body))

                        .unwrap(),

                )

                .await

                .unwrap();

            res.headers().get(header::SET_COOKIE).unwrap().to_str().unwrap().split(';').next().unwrap().to_string()

        }

    };

    register("andy").await; // the first account: the site's administrator

    let bob = register("bob").await;

    create(&h.app, "bob", "game").await;

    let web = |method: &'static str, path: &str, body: Option<String>| {

        let (app, cookie, path) = (h.app.clone(), bob.clone(), path.to_string());

        async move {

            let mut req = Request::builder().method(method).uri(path).header(header::COOKIE, cookie);

            if body.is_some() {

                req = req.header(header::CONTENT_TYPE, "application/x-www-form-urlencoded");

            }

            let res = oxygenhub::router(app).oneshot(req.body(body.map(Body::from).unwrap_or_else(Body::empty)).unwrap()).await.unwrap();

            String::from_utf8_lossy(&res.into_body().collect().await.unwrap().to_bytes()).into_owned()

        }

    };

    let csrf_of = |page: &str| {

        let i = page.find("name=\"_csrf\" value=\"").unwrap() + "name=\"_csrf\" value=\"".len();

        page[i..].split('"').next().unwrap().to_string()

    };

    // No runner of his own yet: he is told how, and cannot switch it on.

    let page = web("GET", "/bob/game/settings", None).await;

    assert!(page.contains("register a runner for this repository") && !page.contains("value=\"own\""), "{page}");

    let page = web("POST", "/bob/game/settings/flow", Some(format!("_csrf={}&flow=own", csrf_of(&page)))).await;

    assert!(page.contains("Register a runner for this repository"), "{page}");

    // He registers one.

    let page = web("GET", "/bob/game/settings", None).await;

    let page = web("POST", "/bob/game/settings/runners/token", Some(format!("_csrf={}", csrf_of(&page)))).await;

    let i = page.find("--token ").unwrap() + "--token ".len();

    let token: String = page[i..].chars().take_while(|c| !c.is_whitespace()).collect();

    let info = serde_json::json!({ "arch": "x86_64", "os": "linux", "version": "0.1.0", "labels": [], "max_jobs": 1 });

    let identity = SecretKey::generate().identity("bobs", "", 1);

    let reg = serde_json::json!({ "token": token, "name": "bobs", "identity": hex::encode(identity.encode()), "info": info });

    let (st, body) = call(&h.app, "POST", "/api/v1/flow/runners/register", None, Some(reg.to_string())).await;

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

    let credential = serde_json::from_str::<serde_json::Value>(&body).unwrap()["credential"].as_str().unwrap().to_string();

    // The site's runners stay a site administrator's to grant; his own he may choose.

    let page = web("GET", "/bob/game/settings", None).await;

    assert!(page.contains("value=\"own\"") && !page.contains("value=\"on\""), "{page}");

    let page = web("POST", "/bob/game/settings/flow", Some(format!("_csrf={}&flow=on", csrf_of(&page)))).await;

    assert!(page.contains("Only site administrators let the site's runners"), "{page}");

    let page = web("POST", "/bob/game/settings/flow", Some(format!("_csrf={}&flow=own", csrf_of(&page)))).await;

    assert!(page.contains("value=\"own\" checked") && page.contains("start runs"), "{page}");

    assert_eq!(db::repos::get(&h.app.db, "bob", "game").await.unwrap().unwrap().flow, "own");

    // A push starts a run; the site's runner is not offered it, his is.

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

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

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

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

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

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

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

    assert_eq!(runs_of(&h.app, "bob", "game").await.len(), 1, "a run started");

    assert!(claim(&h.app).await.is_none(), "the site's runner is not offered it");

    let body = serde_json::json!({ "runner": "ignored", "runtimes": ["microvm"], "info": info }).to_string();

    let (st, job) = call(&h.app, "POST", "/api/v1/flow/claim", Some(&credential), Some(body)).await;

    assert_eq!(st, StatusCode::OK, "{job}");

    assert_eq!(serde_json::from_str::<serde_json::Value>(&job).unwrap()["repo"], "bob/game");

}

  {% if site_admin || own_runner || row.flow == "own" %}

    {% if site_admin %}<label><input type="radio" name="flow" value="on"{% if row.flow == "on" %} checked{% endif %}> on, any runner (the site's too)</label>{% endif %}

    {% if site_admin || own_runner %}<label><input type="radio" name="flow" value="own"{% if row.flow == "own" %} checked{% endif %}> on, own runners only</label>{% endif %}

    {% if site_admin %}<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>{% endif %}

  <p class="small mute"><strong>Own runners only</strong>: jobs go only to runners registered for this repository or its owner (Runners, below), never to the site's. Only site administrators let the site's runners take them. It takes effect at the next push.</p>

  <p class="small mute">To run pipelines on your own machines, register a runner for this repository under <a href="#runners">Runners</a>, then choose <strong>on, own runners only</strong> here. A site administrator can also let the site's runners take its jobs.</p>