A runner's own labels and time limit, from its admin page 7f5f6c056d8f

-- A runner's own settings from the admin page (oxygenhub#98): labels an

-- administrator gives it beside those it reports, and a time limit for

-- the jobs it runs, below the site's.

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

ALTER TABLE flow_runners ADD COLUMN timeout_minutes INTEGER;

    /// Labels an administrator gave it, beside those it reports (#98).

    pub admin_labels: String,

    /// A time limit for its jobs in minutes, below the site's, when set.

    pub timeout_minutes: Option<i64>,

    /// Every label it carries: what it reports, and what an administrator

    /// gave it.

        let mut out: Vec<&str> = self.labels.split(',').filter(|l| !l.is_empty()).collect();

        for l in self.admin_label_list() {

            if !out.contains(&l) {

                out.push(l);

            }

        }

        out

    }

    pub fn admin_label_list(&self) -> Vec<&str> {

        self.admin_labels.split(',').filter(|l| !l.is_empty()).collect()

    }

    /// The labels it reported itself, as the admin page distinguishes them.

    pub fn reported_label_list(&self) -> Vec<&str> {

/// The administrator's settings for a runner (#98).

pub async fn set_limits(pool: &Pool, id: i64, admin_labels: &str, timeout_minutes: Option<i64>) -> sqlx::Result<()> {

    sqlx::query("UPDATE flow_runners SET admin_labels = ?, timeout_minutes = ? WHERE id = ?")

        .bind(admin_labels)

        .bind(timeout_minutes)

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

    // The labels it reports now, or those it registered with, and those

    // an administrator gave it (#98).

    let mut labels: Vec<String> = match &req.info {

        None => me.reported_label_list().into_iter().map(String::from).collect(),

    for l in me.admin_label_list() {

        if !labels.iter().any(|x| x == l) {

            labels.push(l.to_string());

        }

    }

    let mut timeout_s = spec.timeout_s.or(sandbox.timeout_s).unwrap_or(limits.default_s).min(limits.max_s).max(60);

    // ...and never past the runner's own limit, when it has one (#98).

    if let Some(m) = me.timeout_minutes.filter(|m| *m > 0) {

        timeout_s = timeout_s.min(m as u64 * 60).max(60);

    }

pub struct LimitsForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// Comma-separated.

    #[serde(default)]

    labels: String,

    /// Minutes; empty for the site's limit.

    #[serde(default)]

    timeout_minutes: String,

}

/// `POST /admin/runners/{id}/limits`: the labels an administrator gives a

/// runner and its own job time limit (#98).

pub async fn set_limits(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(id): Path<i64>,

    Form(f): Form<LimitsForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/admin/runners/{id}"), &viewer);

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

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

    let r =

        runners::get(&app.db, id).await.map_err(|e| Error::from_db(shell.clone(), e))?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let mut labels: Vec<String> = Vec::new();

    for l in f.labels.split([',', ' ']).map(str::trim).filter(|l| !l.is_empty()) {

        if !l.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')) || l.len() > 40 {

            return Err(Error::bad(shell, format!("label {l:?}: letters, digits, - _ and . only, up to 40 characters")));

        }

        if !labels.iter().any(|x| x == l) {

            labels.push(l.to_string());

        }

    }

    let timeout = match f.timeout_minutes.trim() {

        "" => None,

        t => match t.parse::<i64>() {

            Ok(m) if (1..=24 * 60).contains(&m) => Some(m),

            _ => return Err(Error::bad(shell, "a time limit is a whole number of minutes from 1 to 1440")),

        },

    };

    runners::set_limits(&app.db, id, &labels.join(","), timeout).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let words = format!(

        "labels {}; time limit {}",

        if labels.is_empty() { "none".to_string() } else { labels.join(", ") },

        timeout.map(|m| format!("{m} min")).unwrap_or_else(|| "the site's".into())

    );

    accounts::audit(&app.db, Some(&me), "flow.runner.limits", &r.name, &words).await.ok();

    Ok(Redirect::to(&format!("/admin/runners/{id}")).into_response())

}

#[derive(Deserialize)]

    // A runner's own labels and time limit from its page (#98).

    let (_, page) = web("GET", format!("/admin/runners/{}", plex.id), None).await;

    let (st, _) = web(

        "POST",

        format!("/admin/runners/{}/limits", plex.id),

        Some(format!("_csrf={}&labels=gpu%2C+plex&timeout_minutes=5", csrf_of(&page))),

    )

    .await;

    assert_eq!(st, StatusCode::SEE_OTHER);

    let (_, page) = web("GET", format!("/admin/runners/{}", plex.id), None).await;

    assert!(page.contains(">gpu<") && page.contains("5 min for its jobs"), "{page}");

    let (_, body) = call(&h.app, "GET", "/api/v1/runners", Some(&admin_token), None).await;

    let listed: serde_json::Value = serde_json::from_str(&body).unwrap();

    let plex_row = listed.as_array().unwrap().iter().find(|r| r["name"] == "plex").unwrap();

    assert!(plex_row["labels"].as_array().unwrap().iter().any(|l| l == "gpu"), "{plex_row}");

    let (st, _) = web(

        "POST",

        format!("/admin/runners/{}/limits", plex.id),

        Some(format!("_csrf={}&labels=bad%20label%21&timeout_minutes=", csrf_of(&page))),

    )

    .await;

    assert_eq!(st, StatusCode::BAD_REQUEST, "a label with a space or punctuation is refused");

    <dt>Labels</dt><dd>{% for l in r.label_list() %}<span class="lbl">{{ l }}</span> {% endfor %}{% if r.label_list().is_empty() %}<span class="mute">none</span>{% endif %}{% if !r.admin_label_list().is_empty() %} <span class="mute small">({{ r.admin_label_list().len() }} set here)</span>{% endif %}</dd>

    <dt>Time limit</dt><dd>{% if let Some(m) = r.timeout_minutes %}{{ m }} min for its jobs, below the site's{% else %}<span class="mute">the site's</span>{% endif %}</dd>

  <h2>Settings</h2>

  <form class="card" method="post" action="/admin/runners/{{ r.id }}/limits">

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

    <label>Labels given here, beside those it reports{% if !r.reported_label_list().is_empty() %} ({{ r.reported_label_list().join(", ") }}){% endif %}</label>

    <input type="text" name="labels" value="{{ r.admin_labels }}" placeholder="gpu, plex">

    <label>Job time limit in minutes (empty: the site's)</label>

    <input type="number" name="timeout_minutes" min="1" max="1440" value="{% if let Some(m) = r.timeout_minutes %}{{ m }}{% endif %}">

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

  </form>

</section>

<section class="panel">