agents get a per-agent repo limit in their permissions record, orgs are locked
max_repos (default 0, 0..=100) lives in the agent's agent-permissions record and is edited on its permissions panel. The controller applies each agent's own value as max_repo_creation at CreateForgeUser and to existing accounts on change, restart and every five minutes; agent accounts may not create organizations.
This commit is contained in:
parent
dc0d08b7fb
commit
1edeb5c55d
1 changed files with 763 additions and 58 deletions
|
|
@ -25,7 +25,8 @@ use swarm_controller_api::permissions::Permissions;
|
|||
use swarm_queue_client::agent_permissions;
|
||||
use swarm_secret_client::observability::Grant;
|
||||
use swarm_wire::agent_permissions::{
|
||||
AgentPermissions, Import, ImportReply, hive_from_import_subject, import_subject_wildcard,
|
||||
AgentPermissions, DEFAULT_MAX_REPOS, Import, ImportReply, MAX_REPOS, hive_from_import_subject,
|
||||
import_subject_wildcard,
|
||||
};
|
||||
use utoipa::ToSchema;
|
||||
|
||||
|
|
@ -41,8 +42,8 @@ use crate::wanted::WantedWriter;
|
|||
const MAX_ATTEMPTS: usize = 5;
|
||||
|
||||
/// The permissions to store for `req`, whose list is already checked. The list
|
||||
/// replaces the stored one; `unrestricted_internet` left out keeps the one in
|
||||
/// `current`. `internet_log` is stored only as `true`, and a request that sets
|
||||
/// replaces the stored one; `unrestricted_internet` and `max_repos` left out
|
||||
/// keep the ones in `current`. `internet_log` is stored only as `true`, and a request that sets
|
||||
/// `unrestricted_internet` without it turns it off: an agent that moves to
|
||||
/// unrestricted and back to restricted does not come back logging.
|
||||
fn into_stored(req: Permissions, current: &AgentPermissions) -> AgentPermissions {
|
||||
|
|
@ -55,6 +56,7 @@ fn into_stored(req: Permissions, current: &AgentPermissions) -> AgentPermissions
|
|||
permissions: req.permissions,
|
||||
unrestricted_internet: req.unrestricted_internet.or(current.unrestricted_internet),
|
||||
internet_log,
|
||||
max_repos: req.max_repos.or(current.max_repos),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -78,12 +80,49 @@ pub(crate) fn unique(perms: &[Permission]) -> Result<(), String> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
/// Woken when an agent's `max_repos` changes, so the forge pass applies it at
|
||||
/// once instead of at its next tick. A wake with no pass waiting is kept for
|
||||
/// the next one.
|
||||
pub(crate) static MAX_REPOS_CHANGED: tokio::sync::Notify = tokio::sync::Notify::const_new();
|
||||
|
||||
/// The repository limit `record` sets: its `max_repos`, or
|
||||
/// [`DEFAULT_MAX_REPOS`] when it has none. A value above [`MAX_REPOS`], as a
|
||||
/// hand edit could leave, reads as the default with a warning: the stricter
|
||||
/// reading.
|
||||
fn max_repos_of(agent: &str, record: &AgentPermissions) -> u32 {
|
||||
match record.max_repos {
|
||||
None => DEFAULT_MAX_REPOS,
|
||||
Some(n) if n <= MAX_REPOS => n,
|
||||
Some(n) => {
|
||||
tracing::warn!(
|
||||
agent,
|
||||
n,
|
||||
"the stored repository limit is out of range; using the default"
|
||||
);
|
||||
DEFAULT_MAX_REPOS
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `agent`'s repository limit: what its record sets, or [`DEFAULT_MAX_REPOS`]
|
||||
/// when it has no record. A record that does not decode reads as none. Opens
|
||||
/// the bucket, which the controller creates at start anyway.
|
||||
///
|
||||
/// # Errors
|
||||
/// The queue could not be read.
|
||||
pub(crate) async fn max_repos(client: &async_nats::Client, agent: &str) -> anyhow::Result<u32> {
|
||||
let store = agent_permissions::open_or_create(client).await?;
|
||||
let (record, _, _) = read_or_default::<AgentPermissions>(&store, agent).await?;
|
||||
Ok(max_repos_of(agent, &record))
|
||||
}
|
||||
|
||||
/// The stored permissions as the API shows them.
|
||||
fn view(v: AgentPermissions) -> Permissions {
|
||||
Permissions {
|
||||
permissions: v.permissions,
|
||||
unrestricted_internet: v.unrestricted_internet,
|
||||
internet_log: v.internet_log,
|
||||
max_repos: v.max_repos,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -249,6 +288,12 @@ async fn put_with(
|
|||
if let Some(perms) = &req.permissions {
|
||||
unique(perms).map_err(|why| refuse(error_problem(StatusCode::BAD_REQUEST, &why)))?;
|
||||
}
|
||||
if let Some(n) = req.max_repos.filter(|n| *n > MAX_REPOS) {
|
||||
return Err(refuse(error_problem(
|
||||
StatusCode::BAD_REQUEST,
|
||||
&format!("max_repos {n} is more than the {MAX_REPOS} an agent may be given"),
|
||||
)));
|
||||
}
|
||||
let client = queue(&state).map_err(|r| refuse(refused(r)))?;
|
||||
if !live(&state).await.map_err(refuse)?.contains(&agent) {
|
||||
return Err(refuse(error_problem(
|
||||
|
|
@ -283,6 +328,9 @@ async fn put_with(
|
|||
.map_err(|e| queue_problem(&e))?
|
||||
{
|
||||
tracing::info!(%agent, ?value, "set agent permissions");
|
||||
if value.max_repos != current.max_repos {
|
||||
MAX_REPOS_CHANGED.notify_one();
|
||||
}
|
||||
if !revoking {
|
||||
mirror(leaves, &agent, &before, &after)
|
||||
.await
|
||||
|
|
@ -333,12 +381,15 @@ async fn delete_with(
|
|||
let (current, revision, _) = read_or_default::<AgentPermissions>(&store, &agent)
|
||||
.await
|
||||
.map_err(|e| queue_problem(&e))?;
|
||||
// Only the flags outlive a clear: dropping `unrestricted_internet`
|
||||
// would turn an agent created with `false` on, and dropping
|
||||
// `internet_log` would turn a logging agent into an enforced one.
|
||||
// Only the flags and the repository limit outlive a clear: dropping
|
||||
// `unrestricted_internet` would turn an agent created with `false` on,
|
||||
// dropping `internet_log` would turn a logging agent into an enforced
|
||||
// one, and a limit is an operator's decision about repositories, not
|
||||
// part of the permission list.
|
||||
let kept = AgentPermissions {
|
||||
unrestricted_internet: current.unrestricted_internet,
|
||||
internet_log: current.internet_log,
|
||||
max_repos: current.max_repos,
|
||||
..AgentPermissions::default()
|
||||
};
|
||||
mirror(leaves, &agent, &held(¤t), &held(&kept))
|
||||
|
|
@ -438,6 +489,7 @@ pub(crate) fn at_create(
|
|||
permissions: perms,
|
||||
unrestricted_internet,
|
||||
internet_log: None,
|
||||
max_repos: None,
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -467,6 +519,7 @@ fn merged_at_create(
|
|||
} else {
|
||||
current.internet_log
|
||||
},
|
||||
max_repos: value.max_repos.or(current.max_repos),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -810,7 +863,7 @@ pub(crate) mod tests {
|
|||
use axum::http::StatusCode;
|
||||
use hive_types::Permission;
|
||||
use swarm_secret_client::observability::Grant;
|
||||
use swarm_wire::agent_permissions::{Import, ImportReply};
|
||||
use swarm_wire::agent_permissions::{Import, ImportReply, MAX_REPOS};
|
||||
|
||||
fn stored(json: &str) -> swarm_wire::agent_permissions::AgentPermissions {
|
||||
serde_json::from_str(json).expect("decodes")
|
||||
|
|
@ -821,6 +874,7 @@ pub(crate) mod tests {
|
|||
permissions: None,
|
||||
unrestricted_internet,
|
||||
internet_log,
|
||||
max_repos: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -886,6 +940,99 @@ pub(crate) mod tests {
|
|||
);
|
||||
}
|
||||
|
||||
/// An agent's repository limit is its own: a change to one agent's leaves
|
||||
/// every other agent at its limit, a `PUT` that leaves the field out and a
|
||||
/// `DELETE` keep it, and a limit above the range is refused.
|
||||
#[tokio::test]
|
||||
async fn an_agents_repo_limit_is_its_own_and_survives_other_changes() {
|
||||
use crate::wanted::WantedWriter;
|
||||
use swarm_wire::wanted::AgentState;
|
||||
|
||||
let nats = TestNats::start();
|
||||
let client = nats.client().await;
|
||||
let state = crate::agent_limits::tests::declared(&client).await;
|
||||
WantedWriter::new(client.clone())
|
||||
.set("pr1ma", "iris", AgentState::Up)
|
||||
.await
|
||||
.expect("declare iris");
|
||||
let limit = |n| Permissions {
|
||||
max_repos: Some(n),
|
||||
..Permissions::default()
|
||||
};
|
||||
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), 0);
|
||||
// A change wakes the forge pass; drain stale wakes first.
|
||||
while tokio::time::timeout(
|
||||
std::time::Duration::from_millis(1),
|
||||
super::MAX_REPOS_CHANGED.notified(),
|
||||
)
|
||||
.await
|
||||
.is_ok()
|
||||
{}
|
||||
assert_eq!(
|
||||
put(&state, "atlas", limit(3))
|
||||
.await
|
||||
.expect("set")
|
||||
.0
|
||||
.max_repos,
|
||||
Some(3)
|
||||
);
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), 3);
|
||||
tokio::time::timeout(
|
||||
std::time::Duration::from_secs(5),
|
||||
super::MAX_REPOS_CHANGED.notified(),
|
||||
)
|
||||
.await
|
||||
.expect("the change wakes the forge pass");
|
||||
assert_eq!(
|
||||
super::max_repos(&client, "iris").await.unwrap(),
|
||||
0,
|
||||
"another agent's limit is not changed"
|
||||
);
|
||||
let _ = put(&state, "iris", limit(7)).await.expect("set");
|
||||
assert_eq!(super::max_repos(&client, "iris").await.unwrap(), 7);
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), 3);
|
||||
|
||||
// A PUT without the field, and a DELETE, keep the limit.
|
||||
let _ = put(&state, "atlas", granted()).await.expect("set");
|
||||
assert_eq!(get(&state, "atlas").await.max_repos, Some(3));
|
||||
delete_agent_permissions(State(state.clone()), Path("atlas".to_owned()))
|
||||
.await
|
||||
.expect("cleared");
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), 3);
|
||||
|
||||
let problem = put(&state, "atlas", limit(MAX_REPOS + 1))
|
||||
.await
|
||||
.expect_err("over the range");
|
||||
assert_eq!(problem.status, Some(StatusCode::BAD_REQUEST), "{problem:?}");
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), 3);
|
||||
let _ = put(&state, "atlas", limit(MAX_REPOS))
|
||||
.await
|
||||
.expect("control: the top of the range is stored");
|
||||
assert_eq!(super::max_repos(&client, "atlas").await.unwrap(), MAX_REPOS);
|
||||
}
|
||||
|
||||
/// A stored limit above the range, as a hand edit could leave it, reads as
|
||||
/// none rather than as that many repositories.
|
||||
#[test]
|
||||
fn a_stored_limit_above_the_range_reads_as_none() {
|
||||
let read = |json: &str| super::max_repos_of("atlas", &stored(json));
|
||||
assert_eq!(read(r#"{"max_repos":5000}"#), 0);
|
||||
assert_eq!(read("{}"), 0);
|
||||
assert_eq!(read(r#"{"max_repos":7}"#), 7, "control: in range");
|
||||
}
|
||||
|
||||
/// A create keeps the stored limit and does not set one.
|
||||
#[test]
|
||||
fn a_create_keeps_the_repo_limit() {
|
||||
let current = stored(r#"{"max_repos":4}"#);
|
||||
assert_eq!(
|
||||
super::merged_at_create(&stored("{}"), ¤t, true).max_repos,
|
||||
Some(4)
|
||||
);
|
||||
assert_eq!(super::at_create(None, None).expect("valid").max_repos, None);
|
||||
}
|
||||
|
||||
pub(crate) async fn published(client: &async_nats::Client, agent: &str) -> Option<String> {
|
||||
let store = swarm_queue_client::agent_permissions::open_or_create(client)
|
||||
.await
|
||||
|
|
@ -902,6 +1049,7 @@ pub(crate) mod tests {
|
|||
permissions: Some(vec![Permission::ManageRootAgent]),
|
||||
unrestricted_internet: None,
|
||||
internet_log: None,
|
||||
max_repos: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -947,6 +1095,7 @@ pub(crate) mod tests {
|
|||
permissions: Some(Vec::new()),
|
||||
unrestricted_internet: None,
|
||||
internet_log: None,
|
||||
max_repos: None,
|
||||
};
|
||||
let _ = put(&state, "atlas", none.clone()).await.expect("set");
|
||||
assert_eq!(
|
||||
|
|
@ -975,6 +1124,7 @@ pub(crate) mod tests {
|
|||
permissions: None,
|
||||
unrestricted_internet: Some(false),
|
||||
internet_log: Some(true),
|
||||
max_repos: None,
|
||||
};
|
||||
let stored = put(&state, "atlas", log.clone()).await.expect("set").0;
|
||||
assert_eq!(stored, log);
|
||||
|
|
@ -997,6 +1147,7 @@ pub(crate) mod tests {
|
|||
permissions: None,
|
||||
unrestricted_internet: Some(true),
|
||||
internet_log: None,
|
||||
max_repos: None,
|
||||
};
|
||||
let _ = put(&state, "atlas", on.clone()).await.expect("set");
|
||||
let off = Permissions {
|
||||
|
|
@ -1144,6 +1295,7 @@ pub(crate) mod tests {
|
|||
permissions: Some(perms.to_vec()),
|
||||
unrestricted_internet: None,
|
||||
internet_log: None,
|
||||
max_repos: None,
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue