variables.rs 100.0%

80 of 80 lines run, 26 of 41 functions · run #520 on main · run missed

//! Variables for OxygenFlow jobs (hub spec §13.2, oxygenhub#102): plain
//! `NAME=value` pairs kept per site, organisation and repository. A job
//! gets its repository's effective set, inner levels overriding outer, as
//! the claim's `env`; Flow sets them under `FLOW_*` and the pipeline's
//! own `env`. They are not secrets and are shown in full on the settings
//! pages; secrets are mounted by Flow (OxygenFlow spec §9).

use crate::db::{now_ms, Pool};
use crate::levels::{self, Scope};
use sqlx::FromRow;
use std::collections::BTreeMap;

/// How many a level may hold.
pub const MAX_PER_LEVEL: usize = 100;
/// The longest value.
pub const MAX_VALUE: usize = 4096;

#[derive(Clone, Debug, FromRow)]
pub struct Variable {
    pub scope: String,
    pub scope_id: i64,
    pub name: String,
    pub value: String,
    pub updated_ms: i64,
}

/// A variable's name: a letter or `_`, then letters, digits and `_`, up
/// to 64; never `FLOW_*`, which Flow sets itself.
pub fn name_ok(name: &str) -> bool {
    let mut chars = name.chars();
    let first = chars.next().is_some_and(|c| c.is_ascii_alphabetic() || c == '_');
    first && name.len() <= 64 && chars.all(|c| c.is_ascii_alphanumeric() || c == '_') && !name.starts_with("FLOW_")
}

/// A value: up to 4096 characters, no control characters but newline and tab.
pub fn value_ok(value: &str) -> bool {
    value.len() <= MAX_VALUE && !value.chars().any(|c| c.is_control() && c != '\n' && c != '\t')
}

pub async fn list(pool: &Pool, scope: Scope) -> sqlx::Result<Vec<Variable>> {
    sqlx::query_as("SELECT * FROM flow_variables WHERE scope = $1 AND scope_id = $2 ORDER BY name")
        .bind(scope.kind())
        .bind(scope.id())
        .fetch_all(pool)
        .await
}

/// Set a variable at a level, new or changed.
pub async fn set(pool: &Pool, scope: Scope, name: &str, value: &str) -> sqlx::Result<()> {
    sqlx::query(
        "INSERT INTO flow_variables (scope, scope_id, name, value, updated_ms) VALUES ($1, $2, $3, $4, $5) \
         ON CONFLICT (scope, scope_id, name) DO UPDATE SET value = excluded.value, updated_ms = excluded.updated_ms",
    )
    .bind(scope.kind())
    .bind(scope.id())
    .bind(name)
    .bind(value)
    .bind(now_ms())
    .execute(pool)
    .await?;
    Ok(())
}

/// Remove a variable from a level; false when it was not there.
pub async fn delete(pool: &Pool, scope: Scope, name: &str) -> sqlx::Result<bool> {
    let r = sqlx::query("DELETE FROM flow_variables WHERE scope = $1 AND scope_id = $2 AND name = $3")
        .bind(scope.kind())
        .bind(scope.id())
        .bind(name)
        .execute(pool)
        .await?;
    Ok(r.rows_affected() == 1)
}

/// Forget a level's variables, when the organisation or repository goes.
pub async fn delete_scope(pool: &Pool, scope: Scope) -> sqlx::Result<()> {
    sqlx::query("DELETE FROM flow_variables WHERE scope = $1 AND scope_id = $2").bind(scope.kind()).bind(scope.id()).execute(pool).await?;
    Ok(())
}

/// A variable as a level sees it: where it comes from, and whether the
/// level's own value hides it.
#[derive(Clone, Debug)]
pub struct Seen {
    pub variable: Variable,
    /// `the site`, `the acme organisation`, or empty for the level's own.
    pub from: String,
    /// An inner level sets the same name, so this value is not the one used.
    pub overridden: bool,
}

/// Every variable a level sees, outermost first, inherited ones marked
/// overridden where an inner level sets the same name.
pub async fn seen(pool: &Pool, scope: Scope, owner: &str) -> sqlx::Result<Vec<Seen>> {
    let mut lvls = levels::above(pool, scope, owner).await?;
    lvls.push((scope, String::new()));
    let mut out: Vec<Seen> = vec![];
    for (level, from) in lvls {
        for v in list(pool, level).await? {
            for o in out.iter_mut().filter(|o| o.variable.name == v.name) {
                o.overridden = true;
            }
            out.push(Seen { variable: v, from: from.clone(), overridden: false });
        }
    }
    Ok(out)
}

/// The variables a repository's jobs get.
pub async fn env_for_repo(pool: &Pool, repo: &crate::db::repos::RepoRow) -> sqlx::Result<BTreeMap<String, String>> {
    Ok(seen(pool, Scope::Repo(repo.id), &repo.owner)
        .await?
        .into_iter()
        .filter(|s| !s.overridden)
        .map(|s| (s.variable.name, s.variable.value))
        .collect())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn names_and_values_are_checked() {
        assert!(name_ok("CC") && name_ok("_x") && name_ok("RUST_LOG"));
        assert!(!name_ok("") && !name_ok("1A") && !name_ok("A-B") && !name_ok("FLOW_REPO") && !name_ok(&"A".repeat(65)));
        assert!(value_ok("clang") && value_ok("two\nlines\twith tab") && value_ok(""));
        assert!(!value_ok("a\u{0}b") && !value_ok(&"x".repeat(MAX_VALUE + 1)));
    }
}

1		//! Variables for OxygenFlow jobs (hub spec §13.2, oxygenhub#102): plain
2		//! `NAME=value` pairs kept per site, organisation and repository. A job
3		//! gets its repository's effective set, inner levels overriding outer, as
4		//! the claim's `env`; Flow sets them under `FLOW_*` and the pipeline's
5		//! own `env`. They are not secrets and are shown in full on the settings
6		//! pages; secrets are mounted by Flow (OxygenFlow spec §9).
7
8		use crate::db::{now_ms, Pool};
9		use crate::levels::{self, Scope};
10		use sqlx::FromRow;
11		use std::collections::BTreeMap;
12
13		/// How many a level may hold.
14		pub const MAX_PER_LEVEL: usize = 100;
15		/// The longest value.
16		pub const MAX_VALUE: usize = 4096;
17
18		#[derive(Clone, Debug, FromRow)]
19		pub struct Variable {
20		pub scope: String,
21		pub scope_id: i64,
22		pub name: String,
23		pub value: String,
24		pub updated_ms: i64,
25		}
26
27		/// A variable's name: a letter or `_`, then letters, digits and `_`, up
28		/// to 64; never `FLOW_*`, which Flow sets itself.
29	12×	pub fn name_ok(name: &str) -> bool {
30	12×	let mut chars = name.chars();
31	12×	let first = chars.next().is_some_and(\|c\| c.is_ascii_alphabetic() \|\| c == '_');
32	43×	first && name.len() <= 64 && chars.all(\|c\| c.is_ascii_alphanumeric() \|\| c == '_') && !name.starts_with("FLOW_")
33	12×	}
34
35		/// A value: up to 4096 characters, no control characters but newline and tab.
36	7×	pub fn value_ok(value: &str) -> bool {
37	35×	value.len() <= MAX_VALUE && !value.chars().any(\|c\| c.is_control() && c != '\n' && c != '\t')
38	7×	}
39
40	759×	pub async fn list(pool: &Pool, scope: Scope) -> sqlx::Result<Vec<Variable>> {
41	759×	sqlx::query_as("SELECT * FROM flow_variables WHERE scope = $1 AND scope_id = $2 ORDER BY name")
42	759×	.bind(scope.kind())
43	759×	.bind(scope.id())
44	759×	.fetch_all(pool)
45	759×	.await
46	759×	}
47
48		/// Set a variable at a level, new or changed.
49	5×	pub async fn set(pool: &Pool, scope: Scope, name: &str, value: &str) -> sqlx::Result<()> {
50	5×	sqlx::query(
51	5×	"INSERT INTO flow_variables (scope, scope_id, name, value, updated_ms) VALUES ($1, $2, $3, $4, $5) \
52	5×	ON CONFLICT (scope, scope_id, name) DO UPDATE SET value = excluded.value, updated_ms = excluded.updated_ms",
53	5×	)
54	5×	.bind(scope.kind())
55	5×	.bind(scope.id())
56	5×	.bind(name)
57	5×	.bind(value)
58	5×	.bind(now_ms())
59	5×	.execute(pool)
60	5×	.await?;
61	5×	Ok(())
62	5×	}
63
64		/// Remove a variable from a level; false when it was not there.
65	1×	pub async fn delete(pool: &Pool, scope: Scope, name: &str) -> sqlx::Result<bool> {
66	1×	let r = sqlx::query("DELETE FROM flow_variables WHERE scope = $1 AND scope_id = $2 AND name = $3")
67	1×	.bind(scope.kind())
68	1×	.bind(scope.id())
69	1×	.bind(name)
70	1×	.execute(pool)
71	1×	.await?;
72	1×	Ok(r.rows_affected() == 1)
73	1×	}
74
75		/// Forget a level's variables, when the organisation or repository goes.
76	1×	pub async fn delete_scope(pool: &Pool, scope: Scope) -> sqlx::Result<()> {
77	1×	sqlx::query("DELETE FROM flow_variables WHERE scope = $1 AND scope_id = $2").bind(scope.kind()).bind(scope.id()).execute(pool).await?;
78	1×	Ok(())
79	1×	}
80
81		/// A variable as a level sees it: where it comes from, and whether the
82		/// level's own value hides it.
83		#[derive(Clone, Debug)]
84		pub struct Seen {
85		pub variable: Variable,
86		/// `the site`, `the acme organisation`, or empty for the level's own.
87		pub from: String,
88		/// An inner level sets the same name, so this value is not the one used.
89		pub overridden: bool,
90		}
91
92		/// Every variable a level sees, outermost first, inherited ones marked
93		/// overridden where an inner level sets the same name.
94	420×	pub async fn seen(pool: &Pool, scope: Scope, owner: &str) -> sqlx::Result<Vec<Seen>> {
95	420×	let mut lvls = levels::above(pool, scope, owner).await?;
96	420×	lvls.push((scope, String::new()));
97	420×	let mut out: Vec<Seen> = vec![];
98	757×	for (level, from) in lvls {
99	757×	for v in list(pool, level).await? {
100	32×	for o in out.iter_mut().filter(\|o\| o.variable.name == v.name) {
101	6×	o.overridden = true;
102	6×	}
103	32×	out.push(Seen { variable: v, from: from.clone(), overridden: false });
104		}
105		}
106	420×	Ok(out)
107	420×	}
108
109		/// The variables a repository's jobs get.
110	160×	pub async fn env_for_repo(pool: &Pool, repo: &crate::db::repos::RepoRow) -> sqlx::Result<BTreeMap<String, String>> {
111	160×	Ok(seen(pool, Scope::Repo(repo.id), &repo.owner)
112	160×	.await?
113	160×	.into_iter()
114	160×	.filter(\|s\| !s.overridden)
115	160×	.map(\|s\| (s.variable.name, s.variable.value))
116	160×	.collect())
117	160×	}
118
119		#[cfg(test)]
120		mod tests {
121		use super::*;
122
123		#[test]
124	1×	fn names_and_values_are_checked() {
125	1×	assert!(name_ok("CC") && name_ok("_x") && name_ok("RUST_LOG"));
126	1×	assert!(!name_ok("") && !name_ok("1A") && !name_ok("A-B") && !name_ok("FLOW_REPO") && !name_ok(&"A".repeat(65)));
127	1×	assert!(value_ok("clang") && value_ok("two\nlines\twith tab") && value_ok(""));
128	1×	assert!(!value_ok("a\u{0}b") && !value_ok(&"x".repeat(MAX_VALUE + 1)));
129	1×	}
130		}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

Coverage / crates/hub/src/variables.rs 100.0%

Keyboard