Runners' facts kept from their claims and shown 2fb70d019851

-- What each runner measured about itself at its last claim (oxygenflow#40,

-- OxygenFlow spec §11.1): free disk, load, speed and kernel.

ALTER TABLE flow_runners ADD COLUMN free_disk_mib INTEGER;

ALTER TABLE flow_runners ADD COLUMN load_x100 INTEGER;

ALTER TABLE flow_runners ADD COLUMN speed INTEGER;

ALTER TABLE flow_runners ADD COLUMN speed_class INTEGER;

ALTER TABLE flow_runners ADD COLUMN kernel TEXT NOT NULL DEFAULT '';

    /// What it measured at its last claim (oxygenflow#40): free disk in

    /// MiB, the 1-minute load ×100, its speed score (100 on the reference

    /// machine) and class 1–5, its kernel.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub free_disk_mib: Option<i64>,

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub load_x100: Option<i64>,

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub speed: Option<i64>,

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub speed_class: Option<i64>,

    #[serde(default, skip_serializing_if = "String::is_empty")]

    pub kernel: String,

        free_disk_mib: r.free_disk_mib,

        load_x100: r.load_x100,

        speed: r.speed,

        speed_class: r.speed_class,

        kernel: r.kernel,

    /// What it measured at its last claim (oxygenflow#40): free disk (MiB),

    /// the 1-minute load ×100, its speed score and class, its kernel.

    pub free_disk_mib: Option<i64>,

    pub load_x100: Option<i64>,

    pub speed: Option<i64>,

    pub speed_class: Option<i64>,

    pub kernel: String,

/// Keep what a runner measured about itself at a claim (oxygenflow#40).

pub async fn set_facts(pool: &Pool, id: i64, f: &flow_core::api::Facts) -> sqlx::Result<()> {

    sqlx::query("UPDATE flow_runners SET free_disk_mib = ?, load_x100 = ?, speed = ?, speed_class = ?, kernel = ? WHERE id = ?")

        .bind(f.free_disk_mib.map(|v| v.min(i64::MAX as u64) as i64))

        .bind(f.load_x100.map(i64::from))

        .bind(f.speed.map(i64::from))

        .bind(f.speed_class.map(i64::from))

        .bind(f.kernel.clone().unwrap_or_default())

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

impl Runner {

    /// Its facts as words for the Runners page: "speed 100 (class 3) · load

    /// 1.12 · 41 GiB free"; empty when it has sent none.

    pub fn facts_line(&self) -> String {

        let mut out = Vec::new();

        if let Some(s) = self.speed {

            out.push(format!("speed {s} (class {})", self.speed_class.unwrap_or(0)));

        }

        if let Some(l) = self.load_x100 {

            out.push(format!("load {:.2}", l as f64 / 100.0));

        }

        if let Some(d) = self.free_disk_mib {

            out.push(if d >= 1024 { format!("{} GiB free", d / 1024) } else { format!("{d} MiB free") });

        }

        out.join(" · ")

    }

}

    if let Some(f) = &req.facts {

        db::runners::set_facts(&app.db, me.id, f).await?;

    }

/// oxygenflow#40: what a runner measured at its claim is kept and shown.

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

async fn a_runners_facts_are_kept_from_its_claim() {

    let h = hub().await;

    db::accounts::create_account(&h.app.db, "andy", "[email protected]", "x", "salt", true).await.unwrap();

    let body = r#"{"runner":"test-1","runtimes":["microvm"],"facts":{"free_disk_mib":42000,"load_x100":112,"speed":100,"speed_class":3,"kernel":"7.0.0"}}"#;

    let (st, _) = call(&h.app, "POST", "/api/v1/flow/claim", Some("runner-secret"), Some(body.into())).await;

    assert_eq!(st, StatusCode::NO_CONTENT, "nothing to run, but the facts are kept");

    let (st, out) = call(&h.app, "GET", "/api/v1/runners", Some("site"), None).await;

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

    let v: serde_json::Value = serde_json::from_str(&out).unwrap();

    let r = &v[0];

    assert_eq!(

        (r["speed"].as_i64(), r["speed_class"].as_i64(), r["free_disk_mib"].as_i64(), r["load_x100"].as_i64()),

        (Some(100), Some(3), Some(42000), Some(112))

    );

    let row = db::runners::list(&h.app.db).await.unwrap().remove(0);

    assert_eq!(row.facts_line(), "speed 100 (class 3) · load 1.12 · 41 GiB free");

}

- **Architecture** (OxygenFlow spec §11.2–§11.3, oxygenflow#36): a runner reports each image's architecture on its claims (`image_archs`), kept in `flow_images`; a job is offered only to a runner whose architecture matches its sandbox's `arch`, else its image's as known; unknown matches, as before. The queue says which architecture a waiting job asks for. **Images by hash** (oxygenflow#39, Jetstream): `flow rootfs push HASH` sends a rootfs image as the FastCDC chunks the hub lacks (`POST /flow/images/missing`, `PUT /flow/images/chunks/{hash}`, by a token that may write repositories) and then its manifest (`PUT /flow/images/{hash}`), which the hub accepts only when every chunk is held and they make an image with that hash; chunks are kept zstd-compressed under `<data>/images`, shared by every image, and `jet_images` lists what is held. Runners and accounts fetch with `GET /flow/images/{hash}` and `GET /flow/images/chunks/{hash}`. A runner whose claims say `fetches_images` is offered jobs whose image only the hub holds, and fetches it before its preflight. Each claim also carries the runner's `facts` (OxygenFlow spec §11.1, oxygenflow#40): free disk, load, speed score and class, kernel; the hub keeps the latest on the runner, shows them on Admin › Runners and in `GET /runners`. A placement pass every 15 seconds works out why each ready queued job no runner can take waits, from what each online runner offered at its last claim (scope, tier, architecture, image held, labels, memory and CPUs, a recent decline), and shows it on the job (API `waiting`, `oh run view` and `oh run watch`, its panel open on the run page) and in its check's summary, so a proposal says why its check is stuck (#28).

    <td class="small">{% if r.arch.is_empty() %}<span class="mute">unknown</span>{% else %}{{ r.arch }} · {{ r.os }} · flow {{ r.version }}{% endif %}{% let f = r.facts_line() %}{% if !f.is_empty() %}<br><span class="mute" title="Measured by the runner at its last claim{% if !r.kernel.is_empty() %}; kernel {{ r.kernel }}{% endif %}">{{ f }}</span>{% endif %}</td>