API: add access policy management and source deny rules

This commit is contained in:
Alexey
2026-11-06 22:37:15 +03:00
parent af806d2f3d
commit b1d8f221d6
24 changed files with 1885 additions and 55 deletions
+350
View File
@@ -0,0 +1,350 @@
//! Administrative access defaults and CIDR shaping; publication uses the watcher.
use std::collections::{BTreeMap, HashMap, HashSet};
use serde::{Deserialize, Serialize};
use super::ApiShared;
use super::config_edit::{RuntimeBaseline, RuntimeFence};
use super::config_store::{
FieldEdit, compute_snapshot_revision, load_candidate_snapshot, load_config_snapshot,
prepare_field_edits, write_atomic_with_runtime_check,
};
use super::model::ApiFailure;
use super::patch::{Patch, patch_field};
use crate::config::{
AccessConfig, CidrRateLimitKey, ProxyConfig, RateLimitBps, UserMaxUniqueIpsMode,
};
pub(super) const FIELDS: &[&str] = &[
"user_max_tcp_conns_global_each",
"user_max_unique_ips_global_each",
"user_max_unique_ips_mode",
"user_max_unique_ips_window_secs",
"cidr_rate_limits",
];
#[derive(Debug, Serialize, PartialEq)]
pub(super) struct Policy {
user_max_tcp_conns_global_each: usize,
user_max_unique_ips_global_each: usize,
user_max_unique_ips_mode: UserMaxUniqueIpsMode,
user_max_unique_ips_window_secs: u64,
cidr_rate_limits: BTreeMap<String, RateLimitBps>,
}
impl From<&AccessConfig> for Policy {
fn from(access: &AccessConfig) -> Self {
Self {
user_max_tcp_conns_global_each: access.user_max_tcp_conns_global_each,
user_max_unique_ips_global_each: access.user_max_unique_ips_global_each,
user_max_unique_ips_mode: access.user_max_unique_ips_mode,
user_max_unique_ips_window_secs: access.user_max_unique_ips_window_secs,
cidr_rate_limits: access
.cidr_rate_limits
.iter()
.map(|(key, value)| (key.to_string(), *value))
.collect(),
}
}
}
#[derive(Debug, Serialize)]
pub(super) struct PolicyState {
desired: Policy,
effective: Policy,
runtime: RuntimeBaseline,
published_match: bool,
effective_scope: &'static str,
subsystem_convergence: &'static str,
apply_mode: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
changed_paths: Option<Vec<String>>,
}
fn view(
desired: &ProxyConfig,
fence: &RuntimeFence,
changed_paths: Option<Vec<String>>,
) -> PolicyState {
let desired = Policy::from(&desired.access);
let effective = Policy::from(&fence.config.access);
PolicyState {
published_match: desired == effective,
desired,
effective,
runtime: fence.baseline(),
effective_scope: "active_config_snapshot",
subsystem_convergence: "unknown",
apply_mode: "watcher",
changed_paths,
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct PolicyPatch {
#[serde(default, deserialize_with = "patch_field")]
user_max_tcp_conns_global_each: Patch<usize>,
#[serde(default, deserialize_with = "patch_field")]
user_max_unique_ips_global_each: Patch<usize>,
#[serde(default, deserialize_with = "patch_field")]
user_max_unique_ips_mode: Patch<UserMaxUniqueIpsMode>,
#[serde(default, deserialize_with = "patch_field")]
user_max_unique_ips_window_secs: Patch<u64>,
#[serde(default, deserialize_with = "patch_field")]
cidr_rate_limits: Patch<BTreeMap<String, Option<RateInput>>>,
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RateInput {
#[serde(default)]
up_bps: u64,
#[serde(default)]
down_bps: u64,
}
fn scalar<T: Serialize>(
field: &str,
patch: Patch<T>,
current: &mut T,
default: T,
edits: &mut Vec<FieldEdit>,
) -> Result<(), ApiFailure> {
let value = match patch {
Patch::Unchanged => return Ok(()),
Patch::Remove => {
*current = default;
None
}
Patch::Set(value) => {
let rendered = toml::Value::try_from(&value).map_err(|_| {
ApiFailure::bad_request("Policy value cannot be represented in TOML")
})?;
*current = value;
Some(rendered)
}
};
edits.push(FieldEdit::new(&["access", field], value));
Ok(())
}
fn parse_key(key: &str) -> Result<CidrRateLimitKey, ApiFailure> {
serde_json::from_value(serde_json::Value::String(key.to_owned())).map_err(|_| {
ApiFailure::bad_request("cidr_rate_limits keys must be CIDRs or *4/N, *6/N, */N templates")
})
}
fn apply(
loaded: &crate::config::ParsedConfigSource,
body: PolicyPatch,
) -> Result<(ProxyConfig, Vec<FieldEdit>), ApiFailure> {
let mut config = loaded.config.clone();
let defaults = AccessConfig::default();
let access = &mut config.access;
let mut edits = Vec::new();
scalar(
"user_max_tcp_conns_global_each",
body.user_max_tcp_conns_global_each,
&mut access.user_max_tcp_conns_global_each,
defaults.user_max_tcp_conns_global_each,
&mut edits,
)?;
scalar(
"user_max_unique_ips_global_each",
body.user_max_unique_ips_global_each,
&mut access.user_max_unique_ips_global_each,
defaults.user_max_unique_ips_global_each,
&mut edits,
)?;
scalar(
"user_max_unique_ips_mode",
body.user_max_unique_ips_mode,
&mut access.user_max_unique_ips_mode,
defaults.user_max_unique_ips_mode,
&mut edits,
)?;
scalar(
"user_max_unique_ips_window_secs",
body.user_max_unique_ips_window_secs,
&mut access.user_max_unique_ips_window_secs,
defaults.user_max_unique_ips_window_secs,
&mut edits,
)?;
match body.cidr_rate_limits {
Patch::Unchanged => {}
Patch::Remove => {
access.cidr_rate_limits.clear();
edits.push(FieldEdit::new(&["access", "cidr_rate_limits"], None));
}
Patch::Set(changes) => {
let sources = loaded
.source_contents
.values()
.map(|source| {
toml::from_str::<toml::Value>(source).map_err(|_| {
ApiFailure::new(
hyper::StatusCode::CONFLICT,
"config_patch_not_atomic",
"Invalid independent policy source",
)
})
})
.collect::<Result<Vec<_>, _>>()?;
let mut authored: HashMap<CidrRateLimitKey, Vec<String>> = HashMap::new();
for source in &sources {
if let Some(rows) = source
.get("access")
.and_then(|v| v.get("cidr_rate_limits"))
.and_then(toml::Value::as_table)
{
for raw in rows.keys() {
authored
.entry(parse_key(raw)?)
.or_default()
.push(raw.clone());
}
}
}
let mut seen = HashSet::new();
for (key, rate) in changes {
let parsed = parse_key(&key)?;
if !seen.insert(parsed.clone()) {
return Err(ApiFailure::bad_request(
"Duplicate normalized CIDR policy key",
));
}
let mut names = authored.remove(&parsed).unwrap_or_default();
if names.len() > 1 {
return Err(ApiFailure::new(
hyper::StatusCode::CONFLICT,
"config_patch_not_atomic",
"CIDR policy key has ambiguous source ownership",
));
}
let raw_key = names.pop().unwrap_or_else(|| parsed.to_string());
let value = if let Some(rate) = rate {
let rate = RateLimitBps {
up_bps: rate.up_bps,
down_bps: rate.down_bps,
};
access.cidr_rate_limits.insert(parsed, rate);
Some(
toml::Value::try_from(rate)
.map_err(|_| ApiFailure::internal("Cannot render CIDR rate"))?,
)
} else {
access.cidr_rate_limits.remove(&parsed);
None
};
edits.push(FieldEdit::new(
&["access", "cidr_rate_limits", &raw_key],
value,
));
}
}
}
if edits.is_empty() {
return Err(ApiFailure::bad_request("Empty access policy patch"));
}
config.validate().map_err(|_| ApiFailure::bad_request("Access policy violates configuration constraints; rates require at least one positive direction, at most 100000000000 bps, and unique auto templates; window_secs must be positive"))?;
Ok((config, edits))
}
pub(super) async fn read(shared: &ApiShared) -> Result<(PolicyState, String), ApiFailure> {
let loaded = load_config_snapshot(&shared.config_path, false)
.await
.map_err(|_| ApiFailure::internal("Cannot load access policy source"))?;
let fence = RuntimeFence::capture(shared, None)?;
Ok((
view(&loaded.config, &fence, None),
compute_snapshot_revision(&loaded.source_contents),
))
}
pub(super) async fn patch(
body: PolicyPatch,
expected: Option<String>,
runtime: Option<String>,
shared: &ApiShared,
) -> Result<(PolicyState, String), ApiFailure> {
let shared = shared.clone();
shared
.clone()
.run_mutation_completion(async move {
let _guard = shared.mutation_lock.lock().await;
let fence = RuntimeFence::capture(&shared, runtime.as_deref())?;
let path = shared.config_path.clone();
let (loaded, desired, owned, changed) = tokio::task::spawn_blocking(move || {
let loaded = ProxyConfig::parse_source(&path)
.map_err(|_| ApiFailure::internal("Cannot load access policy source"))?;
let revision = compute_snapshot_revision(&loaded.source_contents);
if expected.is_some_and(|value| value != revision) {
return Err(ApiFailure::new(
hyper::StatusCode::CONFLICT,
"revision_conflict",
"Config revision mismatch",
));
}
let (desired, edits) = apply(&loaded, body)?;
let owned = prepare_field_edits(&loaded, &path, &edits)?;
// Project only the five public policy fields, off the async executor.
let projection = |config: &ProxyConfig| {
serde_json::to_value(BTreeMap::from([("access", Policy::from(&config.access))]))
.map_err(|_| ApiFailure::internal("Cannot project access policy"))
};
let changed = super::config_projection::changed_paths(
&projection(&loaded.config)?,
&projection(&desired)?,
);
Ok::<_, ApiFailure>((loaded, desired, owned, changed))
})
.await
.map_err(|_| ApiFailure::internal("Policy preparation worker failed"))??;
let base_revision = compute_snapshot_revision(&loaded.source_contents);
let revision = if let Some(owned) = owned {
let candidate = load_candidate_snapshot(
&shared.config_path,
&loaded.source_contents,
owned.owner_path.clone(),
owned.owner_contents.clone(),
)
.await
.map_err(|error| {
ApiFailure::new(
error.status,
error.code,
"Cannot prepare access policy candidate",
)
})?;
if Policy::from(&candidate.config.access) != Policy::from(&desired.access) {
return Err(ApiFailure::internal(
"Persisted policy candidate differs from requested policy",
));
}
fence.ensure_current()?;
write_atomic_with_runtime_check(
shared.config_path.clone(),
base_revision,
owned.owner_path,
owned.expected_owner_contents,
owned.owner_contents,
Some(fence.commit_check()),
)
.await?
} else {
fence.ensure_current()?;
base_revision
};
shared.runtime_events.record(
"api.access.policy.patch.ok",
format!("changed_paths={}", changed.len()),
);
Ok((view(&desired, &fence, Some(changed)), revision))
})
.await
}
#[cfg(test)]
mod tests;
+546
View File
@@ -0,0 +1,546 @@
use super::*;
use crate::api::discovery::http_tests::Fixture;
use crate::maestro::generation::test_runtime_generation;
use serde_json::{Value, json};
const ROUTE: &str = "/v1/access/policy";
pub(in crate::api) fn fixture(source: &str) -> Fixture {
let fixture = Fixture::new(false);
std::fs::write(&fixture.shared.config_path, source).unwrap();
let mut config = ProxyConfig::load(&fixture.shared.config_path).unwrap();
config.server.api = fixture
.shared
.active_runtime
.load()
.config()
.server
.api
.clone();
config.server.api.read_only = false;
fixture
.shared
.active_runtime
.store(test_runtime_generation(1, config));
fixture
}
async fn write(fixture: &Fixture, body: Value) -> (u16, Value) {
let (status, _, data) = fixture
.request_body("PATCH", ROUTE, true, Some(&body), &[])
.await;
(status, data)
}
#[tokio::test]
async fn policy_http_gates_methods_queries_and_secret_exclusion() {
let fixture = Fixture::new(false);
for method in ["GET", "PATCH"] {
assert_eq!(fixture.request(method, ROUTE, false).await.0, 401);
}
assert_eq!(
write(&fixture, json!({"user_max_tcp_conns_global_each": 2}))
.await
.0,
403
);
let (status, allow, _) = fixture.request("POST", ROUTE, true).await;
assert_eq!((status, allow.as_str()), (405, "GET, PATCH"));
assert_eq!(
fixture
.request("GET", "/v1/access/policy?reload=instant", true)
.await
.0,
400
);
let denied = Fixture::new(true);
assert_eq!(denied.request("GET", ROUTE, true).await.0, 403);
let (status, _, data) = fixture.request("GET", ROUTE, true).await;
assert_eq!(status, 200);
assert_eq!(
data["data"]["desired"].as_object().unwrap().len(),
FIELDS.len()
);
assert_eq!(data["data"]["effective_scope"], "active_config_snapshot");
assert_eq!(data["data"]["subsystem_convergence"], "unknown");
assert!(!data.to_string().contains("discovery-test"));
}
#[tokio::test]
async fn scalar_defaults_reset_and_revision_runtime_fences() {
let fixture = fixture("# preserve comment\n");
let (_, _, before) = fixture.request("GET", ROUTE, true).await;
let body = json!({"user_max_tcp_conns_global_each": 7, "user_max_unique_ips_global_each": 3,
"user_max_unique_ips_mode": "time_window", "user_max_unique_ips_window_secs": 91});
let (status, _, after) = fixture
.request_body(
"PATCH",
ROUTE,
true,
Some(&body),
&[
("If-Match", before["revision"].as_str().unwrap()),
(
"If-Runtime-Match",
before["data"]["runtime"]["runtime_match"].as_str().unwrap(),
),
],
)
.await;
assert_eq!(status, 200, "{after}");
assert_eq!(
after["data"]["desired"]["user_max_tcp_conns_global_each"],
7
);
assert_eq!(
after["data"]["effective"]["user_max_tcp_conns_global_each"],
0
);
assert_eq!(after["data"]["published_match"], false);
let source = std::fs::read(&fixture.shared.config_path).unwrap();
for (header, token, code) in [
(
"If-Match",
before["revision"].as_str().unwrap(),
"revision_conflict",
),
("If-Runtime-Match", "dead:1:1", "runtime_conflict"),
] {
let (status, _, error) = fixture
.request_body("PATCH", ROUTE, true, Some(&body), &[(header, token)])
.await;
assert_eq!(status, 409);
assert_eq!(error["error"]["code"], code);
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), source);
}
let (status, after) = write(
&fixture,
json!({"user_max_tcp_conns_global_each": null,
"user_max_unique_ips_global_each": null, "user_max_unique_ips_mode": null,
"user_max_unique_ips_window_secs": null}),
)
.await;
assert_eq!(status, 200, "{after}");
assert_eq!(after["data"]["desired"], before["data"]["desired"]);
let text = std::fs::read_to_string(&fixture.shared.config_path).unwrap();
assert!(!text.contains("user_max_"));
assert!(text.contains("# preserve comment"));
}
#[tokio::test]
async fn cidr_map_updates_replace_rows_and_null_removes_or_clears() {
let fixture = fixture("[access.cidr_rate_limits]\n'192.0.2.0/24'={up_bps=123, down_bps=456}\n");
let (status, body) = write(
&fixture,
json!({"cidr_rate_limits": {
"192.0.2.0/24": {"up_bps": 8000}, "2001:db8::/32": {"down_bps": 9000},
"*4/16": {"up_bps": 80}, "*6/64": {"down_bps": 160}, "*/24": {"up_bps": 320}}}),
)
.await;
assert_eq!(status, 200, "{body}");
let rates = &body["data"]["desired"]["cidr_rate_limits"];
assert_eq!(rates.as_object().unwrap().len(), 5);
assert_eq!(rates["192.0.2.0/24"], json!({"up_bps": 8000,"down_bps": 0}));
let (status, body) = write(
&fixture,
json!({"cidr_rate_limits": {"192.0.2.0/24": null,"*4/16": null,"203.0.113.0/24": null}}),
)
.await;
assert_eq!(status, 200, "{body}");
assert_eq!(
body["data"]["desired"]["cidr_rate_limits"]
.as_object()
.unwrap()
.len(),
3
);
let (status, body) = write(&fixture, json!({"cidr_rate_limits": null})).await;
assert_eq!(status, 200, "{body}");
assert_eq!(body["data"]["desired"]["cidr_rate_limits"], json!({}));
assert!(
!std::fs::read_to_string(&fixture.shared.config_path)
.unwrap()
.contains("cidr_rate_limits")
);
}
#[tokio::test]
async fn invalid_and_non_policy_patches_never_write() {
let fixture = fixture("");
let before = std::fs::read(&fixture.shared.config_path).unwrap();
for body in [
json!({}),
json!({"users": null}),
json!({"replay_check": false}),
json!({"user_max_unique_ips_window_secs":0}),
json!({"user_max_unique_ips_mode":"other"}),
json!({"user_max_tcp_conns_global_each":-1}),
json!({"user_max_tcp_conns_global_each":u64::MAX}),
json!({"cidr_rate_limits":[]}),
json!({"cidr_rate_limits":{"invalid":{"up_bps":1}}}),
json!({"cidr_rate_limits":{"*4/33":{"up_bps":1}}}),
json!({"cidr_rate_limits":{"*6/129":{"up_bps":1}}}),
json!({"cidr_rate_limits":{"*/33":{"up_bps":1}}}),
json!({"cidr_rate_limits":{"*/24":{"up_bps":1},"*4/24":{"up_bps":2}}}),
json!({"cidr_rate_limits":{"192.0.2.0/24":{}}}),
json!({"cidr_rate_limits":{"192.0.2.0/24":{"up_bps":100_000_000_001_u64}}}),
json!({"cidr_rate_limits":{"192.0.2.0/24":{"up_bps":1,"typo":null}}}),
] {
let (status, error) = write(&fixture, body.clone()).await;
assert_eq!(status, 400, "{body}: {error}");
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), before);
}
}
#[tokio::test]
async fn structural_edits_preserve_unrelated_values_and_literal_keys() {
for source in [
"access = { user_max_tcp_conns_global_each=4, ignore_time_skew=false } # keep\n",
"access.user_max_tcp_conns_global_each=4\naccess.ignore_time_skew=false # keep\n",
"['access']\nuser_max_tcp_conns_global_each=4\nignore_time_skew=false # keep\n",
] {
let fixture = fixture(source);
let (status, result) = write(
&fixture,
json!({"user_max_tcp_conns_global_each": null,
"cidr_rate_limits":{"192.0.2.0/24":{"up_bps":8000}}}),
)
.await;
assert_eq!(status, 200, "{result}");
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert!(!cfg.access.ignore_time_skew);
assert_eq!(cfg.access.cidr_rate_limits.len(), 1);
assert!(
std::fs::read_to_string(&fixture.shared.config_path)
.unwrap()
.contains("# keep")
);
}
}
#[tokio::test]
async fn include_owner_selection_and_cross_source_rejection() {
let fixture = fixture("");
let root = &fixture.shared.config_path;
let include = root.with_file_name("policy.toml");
let root_text = "include=\"policy.toml\"\n[access]\nuser_max_tcp_conns_global_each=5\n";
let include_text = "[access.cidr_rate_limits]\n'192.0.2.0/24'={up_bps=8000}\n";
std::fs::write(root, root_text).unwrap();
std::fs::write(&include, include_text).unwrap();
let (status, body) = write(
&fixture,
json!({"user_max_tcp_conns_global_each":null,"cidr_rate_limits":null}),
)
.await;
assert_eq!(status, 409, "{body}");
assert_eq!(body["error"]["code"], "config_patch_not_atomic");
assert_eq!(std::fs::read_to_string(root).unwrap(), root_text);
assert_eq!(std::fs::read_to_string(&include).unwrap(), include_text);
let (status, body) = write(
&fixture,
json!({"cidr_rate_limits":{"2001:db8::/32":{"up_bps":16000}}}),
)
.await;
assert_eq!(status, 200, "{body}");
assert_eq!(std::fs::read_to_string(root).unwrap(), root_text);
assert!(
std::fs::read_to_string(include)
.unwrap()
.contains("2001:db8::/32")
);
}
#[tokio::test]
async fn concurrent_policy_writers_with_same_revision_have_one_winner() {
let fixture = fixture("");
let (_, revision) = read(&fixture.shared).await.unwrap();
let one = patch(
serde_json::from_value(json!({"user_max_tcp_conns_global_each":7})).unwrap(),
Some(revision.clone()),
None,
&fixture.shared,
);
let two = patch(
serde_json::from_value(json!({"user_max_unique_ips_global_each":3})).unwrap(),
Some(revision),
None,
&fixture.shared,
);
let (one, two) = tokio::join!(one, two);
assert_ne!(one.is_ok(), two.is_ok());
let error = one.err().or(two.err()).unwrap();
assert_eq!(error.code, "revision_conflict");
}
#[tokio::test]
async fn user_limit_origins_separate_desired_from_published_values() {
let fixture = fixture(
"[access]\nuser_max_tcp_conns_global_each=7\nuser_max_unique_ips_global_each=3\n[access.users]\nalice='0123456789abcdef0123456789abcdef'\n",
);
for (override_value, origin, value) in [
(json!(9), "user_override", json!(9)),
(json!(0), "global_default", json!(7)),
(Value::Null, "global_default", json!(7)),
] {
let (status, _, body) = fixture
.request_body(
"PATCH",
"/v1/users/alice",
true,
Some(&json!({"max_tcp_conns":override_value,"max_unique_ips":override_value})),
&[],
)
.await;
assert!([200, 202].contains(&status), "{body}");
let desired = &body["data"]["limits"]["desired"]["max_tcp_conns"];
assert_eq!(desired["origin"], origin);
assert_eq!(desired["value"], value);
assert_eq!(desired["configured_override"], override_value);
let ips = &body["data"]["limits"]["desired"]["max_unique_ips"];
assert_eq!(ips["origin"], origin);
assert_eq!(ips["configured_override"], override_value);
assert_eq!(
ips["value"],
if origin == "user_override" {
json!(9)
} else {
json!(3)
}
);
assert_eq!(
body["data"]["limits"]["effective"]["max_unique_ips"]["value"],
3
);
assert_eq!(
body["data"]["limits"]["effective"]["max_tcp_conns"]["value"],
7
);
}
assert_eq!(
write(&fixture, json!({"user_max_tcp_conns_global_each":0}))
.await
.0,
200
);
let (_, _, body) = fixture.request("GET", "/v1/users/alice", true).await;
assert_eq!(
body["data"]["limits"]["desired"]["max_tcp_conns"]["origin"],
"unlimited"
);
assert_eq!(
body["data"]["limits"]["desired"]["max_tcp_conns"]["value"],
Value::Null
);
assert_eq!(
body["data"]["limits"]["effective"]["max_tcp_conns"]["value"],
7
);
}
#[tokio::test]
async fn persisted_cidr_policy_retains_precedence_units_and_unlimited_direction() {
use crate::proxy::traffic_limiter::{RateDirection, TrafficLimiter};
let fixture = fixture("");
let (status, body) = write(
&fixture,
json!({"cidr_rate_limits":{
"192.0.2.0/24":{"up_bps":8000}, "192.0.2.7/32":{"up_bps":16000},
"2001:db8::/32":{"up_bps":24000}, "2001:db8:1::/48":{"up_bps":32000},
"*4/32":{"up_bps":40000}, "*6/64":{"up_bps":48000}, "*/8":{"up_bps":56000}
}}),
)
.await;
assert_eq!(status, 200, "{body}");
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
// A fresh bucket grants exactly one 20 ms epoch, expressed in bytes.
for (ip, grant) in [
("192.0.2.1", 20),
("192.0.2.7", 40),
("2001:db8::1", 60),
("2001:db8:1::1", 80),
("203.0.113.1", 100),
("2001:db9::1", 120),
] {
let limiter = TrafficLimiter::new();
limiter.apply_policy(HashMap::new(), cfg.access.cidr_rate_limits.clone());
let lease = limiter.acquire_lease("alice", ip.parse().unwrap()).unwrap();
assert_eq!(
lease
.try_reserve(RateDirection::Up, 10_000)
.result()
.granted,
grant,
"{ip}"
);
assert_eq!(
lease
.try_reserve(RateDirection::Down, 10_000)
.result()
.granted,
10_000,
"{ip}"
);
}
assert_eq!(
write(
&fixture,
json!({"cidr_rate_limits":{"*4/32":null,"*6/64":null}})
)
.await
.0,
200
);
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
for ip in ["203.0.113.1", "2001:db9::1"] {
let limiter = TrafficLimiter::new();
limiter.apply_policy(HashMap::new(), cfg.access.cidr_rate_limits.clone());
let lease = limiter.acquire_lease("alice", ip.parse().unwrap()).unwrap();
assert_eq!(
lease
.try_reserve(RateDirection::Up, 10_000)
.result()
.granted,
140
);
}
}
#[tokio::test]
async fn watcher_publishes_policy_without_quota_reset_or_session_cancellation() {
use crate::config::hot_reload::spawn_config_watcher;
use std::{sync::Arc, time::Duration};
use tokio::sync::watch;
let mut fixture = fixture(
"[server.api]\nenabled=true\nread_only=false\nauth_header='Bearer discovery-test'\n[access.users]\nalice='0123456789abcdef0123456789abcdef'\n",
);
let config = fixture.shared.active_runtime.load().config();
let cancellation = tokio_util::sync::CancellationToken::new();
let _cancel_on_drop = cancellation.clone().drop_guard();
let (activation, activated) = watch::channel(false);
let (mut receiver, _, watcher) = spawn_config_watcher(
fixture.shared.config_path.clone(),
config.clone(),
None,
None,
cancellation.clone(),
None,
Some(activated),
Some(fixture.shared.mutation_lock.clone()),
None,
);
let mut runtime = test_runtime_generation(1, (*config).clone());
Arc::get_mut(&mut runtime).unwrap().config_rx = receiver.clone();
runtime.stats.load_user_quota_state("alice", 12345, 6789);
runtime.stats.increment_user_curr_connects("alice");
let stats = runtime.stats.clone();
let quota_path = fixture.shared.quota_state.path().to_path_buf();
Arc::get_mut(&mut fixture.shared).unwrap().quota_state =
crate::quota_state::QuotaStateOwner::new(quota_path.clone(), stats.quota_store());
let checkpoint_before = std::fs::read(&quota_path).ok();
fixture.shared.active_runtime.store(runtime);
let task = tokio::spawn(watcher);
for limit in [7, 2, 0] {
let (status, body) = write(
&fixture,
json!({"user_max_tcp_conns_global_each":limit,"user_max_unique_ips_global_each":limit}),
)
.await;
assert_eq!(status, 200, "{body}");
activation.send_replace(true);
tokio::time::timeout(
Duration::from_secs(5),
receiver.wait_for(|cfg| cfg.access.user_max_tcp_conns_global_each == limit),
)
.await
.unwrap()
.unwrap();
let (_, _, body) = fixture.request("GET", ROUTE, true).await;
assert_eq!(body["data"]["published_match"], true);
assert_eq!(
body["data"]["effective"]["user_max_unique_ips_global_each"],
limit
);
assert_eq!(stats.get_user_quota_used("alice"), 12345);
assert_eq!(
stats.user_quota_snapshot()["alice"].last_reset_epoch_secs,
6789
);
assert_eq!(stats.get_user_curr_connects("alice"), 1);
}
assert_eq!(std::fs::read(&quota_path).ok(), checkpoint_before);
cancellation.cancel();
tokio::time::timeout(Duration::from_secs(5), task)
.await
.unwrap()
.unwrap();
}
#[tokio::test]
async fn prepared_policy_write_rechecks_external_source_and_runtime_publications() {
for runtime_change in [false, true] {
let fixture = fixture("");
let fence = RuntimeFence::capture(&fixture.shared, None).unwrap();
let loaded = ProxyConfig::parse_source(&fixture.shared.config_path).unwrap();
let revision = compute_snapshot_revision(&loaded.source_contents);
let (_, edits) = apply(
&loaded,
serde_json::from_value(json!({"user_max_tcp_conns_global_each":7})).unwrap(),
)
.unwrap();
let owned = prepare_field_edits(&loaded, &fixture.shared.config_path, &edits)
.unwrap()
.unwrap();
if runtime_change {
fixture
.shared
.active_runtime
.store(test_runtime_generation(2, (*fence.config).clone()));
} else {
std::fs::write(&fixture.shared.config_path, "# external operator edit\n").unwrap();
}
let before = std::fs::read(&fixture.shared.config_path).unwrap();
let error = write_atomic_with_runtime_check(
fixture.shared.config_path.clone(),
revision,
owned.owner_path,
owned.expected_owner_contents,
owned.owner_contents,
Some(fence.commit_check()),
)
.await
.unwrap_err();
assert_eq!(
error.code,
if runtime_change {
"runtime_conflict"
} else {
"revision_conflict"
}
);
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), before);
}
}
#[tokio::test]
async fn unreadable_policy_source_does_not_echo_credentials_or_source_excerpts() {
let fixture = fixture("");
let secret = "private-source-credential";
std::fs::write(
&fixture.shared.config_path,
format!("[access]\nuser_max_tcp_conns_global_each='{secret}'\n"),
)
.unwrap();
for method in ["GET", "PATCH"] {
let (status, _, body) = fixture
.request_body(
method,
ROUTE,
true,
Some(&json!({"user_max_tcp_conns_global_each":1})),
&[],
)
.await;
assert_eq!(status, 500);
assert!(!body.to_string().contains(secret));
}
}
+1 -1
View File
@@ -74,7 +74,7 @@ impl RuntimeFence {
}
}
pub(super) fn commit_check(&self) -> CommitCheck {
pub(in crate::api) fn commit_check(&self) -> CommitCheck {
let fence = self.clone();
Arc::new(move || fence.matches())
}
+4 -2
View File
@@ -10,6 +10,7 @@ use super::model::ApiFailure;
// Source-preserving TOML rendering and atomic persistence helpers.
mod dns_overrides;
mod field_edits;
mod persistence;
// Compare-and-replace file persistence and metadata preservation.
mod atomic;
@@ -19,13 +20,14 @@ pub(in crate::api) use atomic::write_atomic;
pub(in crate::api) use atomic::write_atomic_if_unchanged;
pub(in crate::api) use atomic::{CommitCheck, write_atomic_with_runtime_check};
pub(in crate::api) use dns_overrides::upsert_dns_overrides;
pub(in crate::api) use field_edits::{FieldEdit, prepare_field_edits};
#[cfg(test)]
pub(in crate::api) use persistence::save_access_sections_to_disk;
#[cfg(test)]
use persistence::{find_toml_table_bounds, render_access_section, save_sections_to_disk};
pub(in crate::api) use persistence::{
render_server_listeners, render_top_level_section, save_access_sections_to_disk_if_revision,
upsert_toml_table,
render_server_listeners, render_top_level_section, save_access_sections_and_fields_if_revision,
save_access_sections_to_disk_if_revision, upsert_toml_table,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+152
View File
@@ -0,0 +1,152 @@
//! Structural edits to allowlisted scalar fields and literal map keys.
use super::*;
use toml_edit::{DocumentMut, Item, Table};
pub(in crate::api) struct FieldEdit {
pub path: Vec<String>,
pub value: Option<toml::Value>,
}
impl FieldEdit {
pub fn new(path: &[&str], value: Option<toml::Value>) -> Self {
Self {
path: path.iter().map(|part| (*part).to_owned()).collect(),
value,
}
}
}
pub(in crate::api) struct OwnedSourceEdit {
pub owner_path: PathBuf,
pub expected_owner_contents: String,
pub owner_contents: String,
}
fn conflict() -> ApiFailure {
ApiFailure::new(
hyper::StatusCode::CONFLICT,
"config_patch_not_atomic",
"Mutation requires one independently writable config source",
)
}
fn at_path<'a>(document: &'a DocumentMut, path: &[String]) -> Option<&'a Item> {
path.iter()
.try_fold(document.as_item(), |item, key| item.get(key))
}
fn edit(item: &mut Item, path: &[String], value: Option<&toml::Value>) -> Result<(), ApiFailure> {
let Some((key, rest)) = path.split_first() else {
return Err(ApiFailure::internal("Empty configuration edit path"));
};
let table = item.as_table_like_mut().ok_or_else(conflict)?;
if rest.is_empty() {
if let Some(value) = value {
let mut value = value
.to_string()
.parse::<toml_edit::Value>()
.map_err(|_| ApiFailure::internal("Cannot render configuration value"))?;
if let Some(old) = table.get(key).and_then(Item::as_value) {
*value.decor_mut() = old.decor().clone();
}
table.insert(key, Item::Value(value));
} else {
table.remove(key);
}
} else {
if !table.contains_key(key) {
if value.is_none() {
return Ok(());
}
table.insert(key, Item::Table(Table::new()));
}
edit(table.get_mut(key).ok_or_else(conflict)?, rest, value)?;
}
Ok(())
}
/// Exact leaf ownership wins; insertion uses the nearest existing parent.
/// Literal map keys are separate path components, including dots and CIDRs.
pub(in crate::api) fn prepare_field_edits(
loaded: &ParsedConfigSource,
config_path: &Path,
edits: &[FieldEdit],
) -> Result<Option<OwnedSourceEdit>, ApiFailure> {
if edits.is_empty() {
return Ok(None);
}
if loaded
.source_contents
.values()
.any(|source| has_include_inside_table(source))
{
return Err(conflict());
}
let mut sources = loaded
.source_contents
.iter()
.map(|(path, source)| {
source
.parse::<DocumentMut>()
.map(|document| (path.clone(), document))
.map_err(|_| conflict())
})
.collect::<Result<BTreeMap<_, _>, _>>()?;
let mut owners = BTreeSet::new();
let mut effective = Vec::new();
for change in edits {
if change.path.is_empty() {
return Err(ApiFailure::internal("Empty configuration edit path"));
}
let mut found = BTreeSet::new();
for length in (1..=change.path.len()).rev() {
found = sources
.iter()
.filter(|(_, document)| at_path(document, &change.path[..length]).is_some())
.map(|(path, _)| path.clone())
.collect();
if !found.is_empty() {
break;
}
// Removing an absent field is a no-op, not an insertion into a parent.
if change.value.is_none() {
break;
}
}
if found.len() > 1 {
return Err(conflict());
}
if found.is_empty() && change.value.is_none() {
continue;
}
owners.insert(
found
.into_iter()
.next()
.unwrap_or_else(|| normalize_source_path(config_path)),
);
effective.push(change);
}
if effective.is_empty() {
return Ok(None);
}
if owners.len() != 1 {
return Err(conflict());
}
let owner_path = owners.into_iter().next().ok_or_else(conflict)?;
let document = sources.get_mut(&owner_path).ok_or_else(conflict)?;
for change in effective {
edit(document.as_item_mut(), &change.path, change.value.as_ref())?;
}
let expected_owner_contents = loaded
.source_contents
.get(&owner_path)
.ok_or_else(conflict)?
.clone();
Ok(Some(OwnedSourceEdit {
owner_path,
expected_owner_contents,
owner_contents: document.to_string(),
}))
}
+71 -7
View File
@@ -12,8 +12,8 @@ use super::atomic::write_atomic_if_unchanged;
#[cfg(test)]
use super::compute_revision;
use super::{
AccessSection, compute_snapshot_revision, load_candidate_snapshot, load_config_snapshot,
resolve_single_source_owner, toml_path_exists,
AccessSection, FieldEdit, compute_snapshot_revision, load_candidate_snapshot,
load_config_snapshot, prepare_field_edits, resolve_single_source_owner, toml_path_exists,
};
use crate::api::model::ApiFailure;
@@ -112,6 +112,24 @@ pub(in crate::api) async fn save_access_sections_to_disk_if_revision(
cfg: &ProxyConfig,
sections: &[AccessSection],
expected_revision: Option<&str>,
) -> Result<String, ApiFailure> {
save_access_sections_and_fields_if_revision(
config_path,
cfg,
sections,
Vec::new(),
expected_revision,
)
.await
}
/// Commits legacy user tables and precise source-deny edits in one owner file.
pub(in crate::api) async fn save_access_sections_and_fields_if_revision(
config_path: &Path,
cfg: &ProxyConfig,
sections: &[AccessSection],
fields: Vec<FieldEdit>,
expected_revision: Option<&str>,
) -> Result<String, ApiFailure> {
let loaded = load_config_snapshot(config_path, false).await?;
let loaded_revision = compute_snapshot_revision(&loaded.source_contents);
@@ -133,7 +151,17 @@ pub(in crate::api) async fn save_access_sections_to_disk_if_revision(
.is_some_and(|value| toml_path_exists(&value, section.table_name()))
})
});
if applied.is_empty() {
let compare_source_deny = !fields.is_empty();
let precise = if fields.is_empty() {
None
} else {
let source = loaded.clone();
let path = config_path.to_path_buf();
tokio::task::spawn_blocking(move || prepare_field_edits(&source, &path, &fields))
.await
.map_err(|_| ApiFailure::internal("Source edit worker failed"))??
};
if applied.is_empty() && precise.is_none() {
return Ok(loaded_revision);
}
@@ -141,13 +169,31 @@ pub(in crate::api) async fn save_access_sections_to_disk_if_revision(
.iter()
.map(|section| section.table_name())
.collect::<Vec<_>>();
let owner_path = resolve_single_source_owner(&loaded, config_path, &targets)?;
let mut owner_contents = loaded
let table_owner = if targets.is_empty() {
None
} else {
Some(resolve_single_source_owner(&loaded, config_path, &targets)?)
};
if let (Some(table_owner), Some(precise)) = (&table_owner, &precise)
&& table_owner != &precise.owner_path
{
return Err(ApiFailure::new(
hyper::StatusCode::CONFLICT,
"config_patch_not_atomic",
"User tables and source-deny rule require different source owners",
));
}
let owner_path = table_owner
.or_else(|| precise.as_ref().map(|edit| edit.owner_path.clone()))
.ok_or_else(|| ApiFailure::internal("Missing user mutation owner"))?;
let expected_owner_contents = loaded
.source_contents
.get(&owner_path)
.cloned()
.ok_or_else(|| ApiFailure::internal("config source owner is missing from snapshot"))?;
let expected_owner_contents = owner_contents.clone();
let mut owner_contents = precise
.map(|edit| edit.owner_contents)
.unwrap_or_else(|| expected_owner_contents.clone());
for section in applied {
let rendered = render_access_section(cfg, section)?;
owner_contents = upsert_toml_table(&owner_contents, section.table_name(), &rendered);
@@ -159,7 +205,25 @@ pub(in crate::api) async fn save_access_sections_to_disk_if_revision(
owner_path.clone(),
owner_contents.clone(),
)
.await?;
.await
.map_err(|error| {
if compare_source_deny {
ApiFailure::new(
error.status,
error.code,
"Cannot prepare user policy candidate",
)
} else {
error
}
})?;
if compare_source_deny
&& candidate.config.access.user_source_deny != cfg.access.user_source_deny
{
return Err(ApiFailure::internal(
"Persisted source-deny rules differ from requested policy",
));
}
let _candidate_revision = compute_snapshot_revision(&candidate.source_contents);
let revision = write_atomic_if_unchanged(
config_path.to_path_buf(),
+2 -2
View File
@@ -29,8 +29,8 @@
{"path":"access.user_rate_limits.{username}","value":{"type":"object"},"default_kind":"map_entry","sensitivity":"public","description":"Configuration value for access.user_rate_limits.{username}.","apply":{"watcher":"supported","reload":"supported","effect":"admission_or_accounting_policy_consumption_no_implicit_quota_reset"}},
{"path":"access.user_rate_limits.{username}.down_bps","value":{"type":"integer","minimum":0,"maximum":100000000000},"default_kind":"map_entry","sensitivity":"public","description":"Download limit in bits-per-second within `0..=100_000_000_000`; `0` means unlimited.","unit":"bits_per_second","apply":{"watcher":"supported","reload":"supported","effect":"admission_or_accounting_policy_consumption_no_implicit_quota_reset"},"constraints":["At least one direction must be nonzero; zero means unlimited for that direction."]},
{"path":"access.user_rate_limits.{username}.up_bps","value":{"type":"integer","minimum":0,"maximum":100000000000},"default_kind":"map_entry","sensitivity":"public","description":"Upload limit in bits-per-second within `0..=100_000_000_000`; `0` means unlimited.","unit":"bits_per_second","apply":{"watcher":"supported","reload":"supported","effect":"admission_or_accounting_policy_consumption_no_implicit_quota_reset"},"constraints":["At least one direction must be nonzero; zero means unlimited for that direction."]},
{"path":"access.user_source_deny","value":{"type":"object","additionalProperties":{"type":"array","items":{"type":"string","format":"cidr"}}},"default_kind":"type_default","sensitivity":"public","description":"Per-username client source IP/CIDR deny list. Checked after successful authentication; matching IPs get the same rejection path as invalid auth (handshake fails closed for that connection).","apply":{"watcher":"unsupported","reload":"supported","effect":"new_generation_with_instant_or_drain_session_policy"},"constraints":["Current strict-key validation does not recognize access.user_source_deny; no watcher overlay."]},
{"path":"access.user_source_deny.{username}","value":{"type":"array","items":{"type":"string","format":"cidr"}},"default_kind":"map_entry","sensitivity":"public","description":"Configuration value for access.user_source_deny.{username}.","apply":{"watcher":"unsupported","reload":"supported","effect":"new_generation_with_instant_or_drain_session_policy"},"constraints":["Current strict-key validation does not recognize access.user_source_deny; no watcher overlay."]},
{"path":"access.user_source_deny","value":{"type":"object","additionalProperties":{"type":"array","items":{"type":"string","format":"cidr"}}},"default_kind":"type_default","sensitivity":"public","description":"Per-username client source IP/CIDR deny list. Checked after successful authentication; matching IPs get the same rejection path as invalid auth (handshake fails closed for that connection).","apply":{"watcher":"unsupported","reload":"supported","effect":"new_generation_with_instant_or_drain_session_policy"},"constraints":["Strict-key validation accepts this map. Generation reload is required; no watcher overlay. Deleting a user retains its rule."]},
{"path":"access.user_source_deny.{username}","value":{"type":"array","items":{"type":"string","format":"cidr"}},"default_kind":"map_entry","sensitivity":"public","description":"Configuration value for access.user_source_deny.{username}.","apply":{"watcher":"unsupported","reload":"supported","effect":"new_generation_with_instant_or_drain_session_policy"},"constraints":["Strict-key validation accepts this map. Generation reload is required; no watcher overlay. Deleting a user retains its rule."]},
{"path":"access.users","value":{"type":"object","additionalProperties":{"type":"string"}},"default_kind":"redacted","sensitivity":"credential","description":"Configuration value for access.users.","apply":{"watcher":"supported","reload":"supported","effect":"admission_or_accounting_policy_consumption_no_implicit_quota_reset"}},
{"path":"access.users.{username}","value":{"type":"string","minLength":32,"maxLength":32,"pattern":"^[0-9A-Fa-f]{32}$"},"default_kind":"redacted","sensitivity":"credential","description":"Configuration value for access.users.{username}.","apply":{"watcher":"supported","reload":"supported","effect":"admission_or_accounting_policy_consumption_no_implicit_quota_reset"}},
{"path":"censorship","value":{"type":"object"},"default_kind":"nested_fields","sensitivity":"public","description":"Anti-censorship behavior and traffic shaping configuration.","apply":{"watcher":"unsupported","reload":"supported","effect":"new_generation_with_instant_or_drain_session_policy"}},
+2
View File
@@ -40,6 +40,8 @@
{"id": "config_state","method": "GET","path": "/v1/config/state","gate": "always","success": [200]},
{"id": "config_validate","method": "POST","path": "/v1/config/validate","gate": "always","success": [200],"body": "PatchConfigRequest","if_match": true,"if_runtime_match": true,"read_only_operation": true},
{"id": "config_patch","if_runtime_match": true,"method": "PATCH","path": "/v1/config","gate": "always","success": [200,202],"body": "PatchConfigRequest","if_match": true},
{"id": "access_policy_get","method": "GET","path": "/v1/access/policy","gate": "always","success": [200]},
{"id": "access_policy_patch","method": "PATCH","path": "/v1/access/policy","gate": "always","success": [200],"body": "AccessPolicyPatch","if_match": true,"if_runtime_match": true},
{"id": "reload","method": "POST","path": "/v1/system/reload","gate": "always","success": [202],"body": "ReloadRequest","optional_body": true,"if_match": true},
{"id": "reload_status","method": "GET","path": "/v1/system/reload/{id}","gate": "always","success": [200]},
{"id": "users_list","method": "GET","path": "/v1/users","gate": "always","success": [200],"aliases": ["/v1/stats/users"],"credential_bearing": true},
+18
View File
@@ -211,6 +211,13 @@ fn field_api(path: &str) -> FieldApi {
|| path.starts_with(&format!("{prefix}["))
|| path.starts_with(&format!("{prefix}."))
}));
let policy_field = path.strip_prefix("access.").and_then(|path| {
let field = path.split('.').next()?;
crate::api::access_policy::FIELDS
.iter()
.copied()
.find(|candidate| *candidate == field)
});
let user_field = path
.strip_prefix("access.")
.and_then(|path| path.split('.').next())
@@ -223,6 +230,7 @@ fn field_api(path: &str) -> FieldApi {
"user_data_quota" => Some("data_quota_bytes"),
"user_quota_periods" => Some("quota_period"),
"user_max_unique_ips" => Some("max_unique_ips"),
"user_source_deny" => Some("source_deny"),
"user_rate_limits" if path.ends_with(".up_bps") => Some("rate_limit_up_bps"),
"user_rate_limits" if path.ends_with(".down_bps") => Some("rate_limit_down_bps"),
_ => None,
@@ -240,6 +248,16 @@ fn field_api(path: &str) -> FieldApi {
api.read_routes.push("GET /v1/config");
api.write_routes.push("PATCH /v1/config");
api.null_behavior = "ignored_member_then_validate_candidate";
} else if let Some(field) = policy_field {
api.read_routes.push("GET /v1/access/policy");
api.write_routes.push("PATCH /v1/access/policy");
api.request_field = Some(field);
api.non_editable_reason = Some("managed_via_access_policy_api");
api.null_behavior = if field == "cidr_rate_limits" {
"clear_map_or_remove_null_entries"
} else {
"remove_authored_value_restore_type_default"
};
} else if let Some(field) = user_field {
api.read_routes.push("GET /v1/users/{username}");
api.write_routes
+3 -5
View File
@@ -172,11 +172,9 @@ fn api_ownership_aliases_and_null_contracts_match_existing_surfaces() {
.null_behavior,
"remove_user_override_on_patch"
);
assert!(
field(schema, "access.user_source_deny")
.api
.write_routes
.is_empty()
assert_eq!(
field(schema, "access.user_source_deny").api.write_routes,
["POST /v1/users", "PATCH /v1/users/{username}"]
);
assert!(
field(schema, "server.api.listen")
+31
View File
@@ -158,6 +158,37 @@ async fn dispatch(
}
match (method.as_str(), normalized_path) {
("GET" | "PATCH", "/v1/access/policy") => {
if query.is_some_and(|query| !query.is_empty()) {
return Err(ApiFailure::bad_request(
"Access policy does not accept query parameters",
));
}
let (data, revision) = if method == Method::GET {
access_policy::read(shared).await?
} else {
if cfg.server.api.read_only {
return Err(ApiFailure::new(
StatusCode::FORBIDDEN,
"read_only",
"API runs in read-only mode",
));
}
let expected = parse_if_match(req.headers());
let runtime = config_edit::parse_runtime_match(req.headers())?;
let body =
read_json::<access_policy::PolicyPatch>(req.into_body(), body_limit).await?;
access_policy::patch(body, expected, runtime, shared)
.await
.map_err(|error| {
shared
.runtime_events
.record("api.access.policy.patch.failed", error.code);
error
})?
};
Ok(success_response(StatusCode::OK, data, revision))
}
("POST", "/v1/users") => {
fixed_routes::create_user_route(req, shared, cfg, config_rx, request_id, body_limit)
.await
+1 -1
View File
@@ -32,7 +32,7 @@ pub(super) async fn create_user_route(
}
};
let runtime_cfg = config_rx.borrow().clone();
data.user.in_runtime = runtime_cfg.access.users.contains_key(&data.user.username);
users::refresh_runtime_view(&mut data.user, &runtime_cfg);
shared.runtime_events.record(
"api.user.create.ok",
format!("username={}", data.user.username),
+4 -4
View File
@@ -60,7 +60,7 @@ pub(super) async fn handle(
}
};
let runtime_cfg = config_rx.borrow().clone();
data.in_runtime = runtime_cfg.access.users.contains_key(&data.username);
users::refresh_runtime_view(&mut data, &runtime_cfg);
shared
.runtime_events
.record("api.user.enable.ok", format!("username={}", base_user));
@@ -102,7 +102,7 @@ pub(super) async fn handle(
}
};
let runtime_cfg = config_rx.borrow().clone();
data.in_runtime = runtime_cfg.access.users.contains_key(&data.username);
users::refresh_runtime_view(&mut data, &runtime_cfg);
shared
.runtime_events
.record("api.user.disable.ok", format!("username={}", base_user));
@@ -229,7 +229,7 @@ pub(super) async fn handle(
}
};
let runtime_cfg = config_rx.borrow().clone();
data.user.in_runtime = runtime_cfg.access.users.contains_key(&data.user.username);
users::refresh_runtime_view(&mut data.user, &runtime_cfg);
shared.runtime_events.record(
"api.user.rotate_secret.ok",
format!("username={}", base_user),
@@ -293,7 +293,7 @@ pub(super) async fn handle(
}
};
let runtime_cfg = config_rx.borrow().clone();
data.in_runtime = runtime_cfg.access.users.contains_key(&data.username);
users::refresh_runtime_view(&mut data, &runtime_cfg);
shared
.runtime_events
.record("api.user.patch.ok", format!("username={}", data.username));
+2 -1
View File
@@ -36,6 +36,7 @@ use crate::transport::middle_proxy::MePool;
use crate::web::control::WebRuntimePublication;
use crate::web::trace::WebTraceStore;
mod access_policy;
mod config_edit;
mod config_projection;
mod config_state;
@@ -306,7 +307,7 @@ fn allowed_methods_for_path(path: &str) -> Option<&'static str> {
"/v1/system/reload" => Some(ALLOW_POST),
"/v1/config/validate" => Some(ALLOW_POST),
"/v1/users" => Some(ALLOW_GET_POST),
"/v1/config" => Some(ALLOW_GET_PATCH),
"/v1/config" | "/v1/access/policy" => Some(ALLOW_GET_PATCH),
_ if user_action_route_matches(path, "/reset-quota") => Some(ALLOW_POST),
_ if user_action_route_matches(path, "/rotate-secret") => Some(ALLOW_POST),
_ if user_action_route_matches(path, "/enable") => Some(ALLOW_POST),
+39
View File
@@ -28,6 +28,9 @@ pub(in crate::api) struct UserInfo {
pub(in crate::api) rate_limit_up_bps: Option<u64>,
pub(in crate::api) rate_limit_down_bps: Option<u64>,
pub(in crate::api) max_unique_ips: Option<usize>,
pub(in crate::api) limits: UserLimitState,
pub(in crate::api) source_deny: Vec<ipnetwork::IpNetwork>,
pub(in crate::api) source_deny_status: SourceDenyState,
pub(in crate::api) current_connections: u64,
pub(in crate::api) active_unique_ips: usize,
pub(in crate::api) active_unique_ips_list: Vec<IpAddr>,
@@ -37,6 +40,37 @@ pub(in crate::api) struct UserInfo {
pub(in crate::api) links: UserLinks,
}
#[derive(Serialize)]
pub(in crate::api) struct InheritedLimit {
pub(in crate::api) value: Option<usize>,
pub(in crate::api) configured_override: Option<usize>,
pub(in crate::api) global_value: usize,
pub(in crate::api) origin: &'static str,
}
#[derive(Serialize)]
pub(in crate::api) struct UserLimitSnapshot {
pub(in crate::api) max_tcp_conns: InheritedLimit,
pub(in crate::api) max_unique_ips: InheritedLimit,
}
#[derive(Serialize)]
pub(in crate::api) struct UserLimitState {
pub(in crate::api) desired: UserLimitSnapshot,
pub(in crate::api) effective: Option<UserLimitSnapshot>,
pub(in crate::api) effective_scope: &'static str,
pub(in crate::api) subsystem_convergence: &'static str,
}
#[derive(Serialize)]
pub(in crate::api) struct SourceDenyState {
pub(in crate::api) effective: Option<Vec<ipnetwork::IpNetwork>>,
pub(in crate::api) runtime_reload_required: Option<bool>,
pub(in crate::api) apply_mode: &'static str,
pub(in crate::api) reload_endpoint: &'static str,
pub(in crate::api) effective_scope: &'static str,
}
#[derive(Serialize)]
pub(in crate::api) struct UserActiveIps {
pub(in crate::api) username: String,
@@ -94,6 +128,9 @@ pub(in crate::api) struct CreateUserRequest {
pub(in crate::api) rate_limit_down_bps: Option<u64>,
pub(in crate::api) max_unique_ips: Option<usize>,
pub(in crate::api) enabled: Option<bool>,
/// Omission retains any orphan rule; null explicitly removes it on recreation.
#[serde(default, deserialize_with = "patch_field")]
pub(in crate::api) source_deny: Patch<Vec<ipnetwork::IpNetwork>>,
}
#[derive(Deserialize)]
@@ -118,6 +155,8 @@ pub(in crate::api) struct PatchUserRequest {
pub(in crate::api) max_unique_ips: Patch<usize>,
#[serde(default, deserialize_with = "patch_field")]
pub(in crate::api) enabled: Patch<bool>,
#[serde(default, deserialize_with = "patch_field")]
pub(in crate::api) source_deny: Patch<Vec<ipnetwork::IpNetwork>>,
}
#[derive(Default, Deserialize)]
+7 -2
View File
@@ -11,7 +11,7 @@ use crate::stats::Stats;
use super::ApiShared;
use super::config_store::{
AccessSection, current_revision, load_config_for_mutation,
save_access_sections_to_disk_if_revision,
save_access_sections_and_fields_if_revision, save_access_sections_to_disk_if_revision,
};
use super::model::{
ApiFailure, CreateUserRequest, CreateUserResponse, PatchUserRequest, RotateSecretRequest,
@@ -24,17 +24,22 @@ use super::patch::Patch;
mod create;
mod lifecycle;
mod links;
mod source_deny;
mod update;
mod view;
pub(super) use create::create_user;
pub(super) use lifecycle::{delete_user, rotate_secret};
use links::{build_user_links, empty_user_links};
use source_deny::apply_source_deny;
pub(super) use update::{patch_user, set_user_enabled};
pub(super) use view::{build_user_quota_list, users_from_config};
pub(super) use view::{build_user_quota_list, refresh_runtime_view, users_from_config};
#[cfg(test)]
mod tests;
#[cfg(test)]
mod period_tests;
#[cfg(test)]
mod source_deny_tests;
+4 -28
View File
@@ -119,6 +119,7 @@ async fn create_user_to_completion(
.user_quota_periods
.insert(body.username.clone(), period);
}
let source_deny_edits = apply_source_deny(&mut cfg, &body.username, body.source_deny)?;
cfg.validate()
.map_err(|e| ApiFailure::bad_request(format!("config validation failed: {}", e)))?;
@@ -154,10 +155,11 @@ async fn create_user_to_completion(
.prepare_user_creation_locked(&body.username, quota_guard)
.await
.map_err(|error| ApiFailure::internal(format!("failed to prepare user quota: {error}")))?;
let revision = save_access_sections_to_disk_if_revision(
let revision = save_access_sections_and_fields_if_revision(
&shared.config_path,
&cfg,
&touched_sections,
source_deny_edits,
Some(&base_revision),
)
.await?;
@@ -196,33 +198,7 @@ async fn create_user_to_completion(
let user = users
.into_iter()
.find(|entry| entry.username == body.username)
.unwrap_or(UserInfo {
username: body.username.clone(),
enabled: cfg.access.is_user_enabled(&body.username),
in_runtime: false,
user_ad_tag: None,
max_tcp_conns: cfg
.access
.user_max_tcp_conns
.get(&body.username)
.copied()
.filter(|limit| *limit > 0)
.or((cfg.access.user_max_tcp_conns_global_each > 0)
.then_some(cfg.access.user_max_tcp_conns_global_each)),
expiration_rfc3339: None,
data_quota_bytes: None,
quota_period: body.quota_period,
rate_limit_up_bps: body.rate_limit_up_bps.filter(|limit| *limit > 0),
rate_limit_down_bps: body.rate_limit_down_bps.filter(|limit| *limit > 0),
max_unique_ips: updated_limit,
current_connections: 0,
active_unique_ips: 0,
active_unique_ips_list: Vec::new(),
recent_unique_ips: 0,
recent_unique_ips_list: Vec::new(),
total_octets: 0,
links: build_user_links(&cfg, &secret, detected_ip_v4, detected_ip_v6),
});
.ok_or_else(|| ApiFailure::internal("Created user is missing from config view"))?;
Ok((CreateUserResponse { user, secret }, revision))
}
+29
View File
@@ -0,0 +1,29 @@
use super::*;
use crate::api::config_store::FieldEdit;
/// Source-deny intent changes only desired TOML; generation admission remains untouched.
pub(super) fn apply_source_deny(
cfg: &mut ProxyConfig,
username: &str,
patch: Patch<Vec<ipnetwork::IpNetwork>>,
) -> Result<Vec<FieldEdit>, ApiFailure> {
let value = match patch {
Patch::Unchanged => return Ok(Vec::new()),
Patch::Remove => {
cfg.access.user_source_deny.remove(username);
None
}
Patch::Set(nets) => {
let value = toml::Value::try_from(&nets)
.map_err(|_| ApiFailure::internal("Cannot render source-deny list"))?;
cfg.access
.user_source_deny
.insert(username.to_owned(), nets);
Some(value)
}
};
Ok(vec![FieldEdit::new(
&["access", "user_source_deny", username],
value,
)])
}
+393
View File
@@ -0,0 +1,393 @@
use super::*;
use crate::api::discovery::http_tests::Fixture;
use crate::maestro::generation::test_runtime_generation;
use serde_json::{Value, json};
use std::sync::Arc;
const USERS: &str = "[general]\nconfig_strict=true\n[access.users]\nalice='0123456789abcdef0123456789abcdef'\nbob='abcdef0123456789abcdef0123456789'\n";
fn fixture(extra: &str) -> Fixture {
let fixture = Fixture::new(false);
std::fs::write(&fixture.shared.config_path, format!("{USERS}{extra}")).unwrap();
publish(&fixture, 1);
fixture
}
fn publish(fixture: &Fixture, generation: u64) {
let mut config = ProxyConfig::load(&fixture.shared.config_path).unwrap();
config.server.api = fixture
.shared
.active_runtime
.load()
.config()
.server
.api
.clone();
config.server.api.read_only = false;
fixture
.shared
.active_runtime
.store(test_runtime_generation(generation, config));
}
async fn patch(fixture: &Fixture, username: &str, body: Value) -> Value {
let (status, _, result) = fixture
.request_body(
"PATCH",
&format!("/v1/users/{username}"),
true,
Some(&body),
&[],
)
.await;
assert!([200, 202].contains(&status), "{result}");
result
}
#[tokio::test]
async fn source_deny_strict_create_get_replace_clear_and_reload_status() {
let fixture = fixture("");
let (status, _, created) = fixture
.request_body(
"POST",
"/v1/users",
true,
Some(&json!({
"username":"alice.two", "source_deny":["192.0.2.0/24","2001:db8::/32"]})),
&[],
)
.await;
assert_eq!(status, 202, "{created}");
assert_eq!(
created["data"]["user"]["source_deny_status"]["runtime_reload_required"],
true
);
assert_eq!(
created["data"]["user"]["source_deny_status"]["reload_endpoint"],
"POST /v1/system/reload"
);
let (_, _, get) = fixture.request("GET", "/v1/users/alice.two", true).await;
assert_eq!(
get["data"]["source_deny"],
json!(["192.0.2.0/24", "2001:db8::/32"])
);
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert!(
cfg.access
.is_user_source_ip_denied("alice.two", "192.0.2.12".parse().unwrap())
);
assert!(
cfg.access
.is_user_source_ip_denied("alice.two", "2001:db8::12".parse().unwrap())
);
assert!(
!cfg.access
.is_user_source_ip_denied("alice.two", "198.51.100.12".parse().unwrap())
);
publish(&fixture, 2);
let (_, _, get) = fixture.request("GET", "/v1/users/alice.two", true).await;
assert_eq!(
get["data"]["source_deny_status"]["runtime_reload_required"],
false
);
for value in [json!(["203.0.113.0/24"]), json!([]), Value::Null] {
let body = patch(&fixture, "alice.two", json!({"source_deny":value})).await;
assert_eq!(
body["data"]["source_deny_status"]["runtime_reload_required"],
true
);
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert_eq!(
cfg.access.user_source_deny.contains_key("alice.two"),
!value.is_null()
);
assert_eq!(
body["data"]["source_deny"],
if value.is_null() { json!([]) } else { value }
);
}
}
#[tokio::test]
async fn source_deny_delete_retains_rules_and_recreation_can_remove_them_explicitly() {
let fixture = fixture(
"[access.user_source_deny]\nalice=['192.0.2.0/24']\nbob=['2001:db8::/32'] # retain bob\n",
);
for clear in [false, true] {
let (status, _, deleted) = fixture.request("DELETE", "/v1/users/alice", true).await;
assert!([200, 202].contains(&status), "{deleted}");
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert_eq!(cfg.access.user_source_deny["alice"].len(), 1);
let mut body = json!({"username":"alice"});
if clear {
body["source_deny"] = Value::Null;
}
let (status, _, created) = fixture
.request_body("POST", "/v1/users", true, Some(&body), &[])
.await;
assert!([201, 202].contains(&status), "{created}");
let user = &created["data"]["user"];
assert_eq!(
user["source_deny"],
if clear {
json!([])
} else {
json!(["192.0.2.0/24"])
}
);
assert_eq!(user["source_deny_status"]["runtime_reload_required"], clear);
assert!(
std::fs::read_to_string(&fixture.shared.config_path)
.unwrap()
.contains("bob=['2001:db8::/32'] # retain bob")
);
}
}
#[tokio::test]
async fn source_deny_edits_exact_included_owner_and_rejects_cross_file_user_patch() {
let fixture = fixture("");
let root = &fixture.shared.config_path;
let include = root.with_file_name("deny.toml");
let root_text = format!("include = \"deny.toml\"\n{USERS}");
let include_text = "[access.user_source_deny]\nalice=['192.0.2.0/24']\n'bob'= ['2001:db8::/32'] # keep literal\n";
std::fs::write(root, &root_text).unwrap();
std::fs::write(&include, include_text).unwrap();
patch(
&fixture,
"alice",
json!({"source_deny":["198.51.100.0/24"]}),
)
.await;
assert_eq!(std::fs::read_to_string(root).unwrap(), root_text);
assert!(
std::fs::read_to_string(&include)
.unwrap()
.contains("'bob'= ['2001:db8::/32'] # keep literal")
);
let before = std::fs::read(&include).unwrap();
let (status, _, error) = fixture
.request_body(
"PATCH",
"/v1/users/alice",
true,
Some(&json!({"secret":"11111111111111111111111111111111","source_deny":null})),
&[],
)
.await;
assert_eq!(status, 409, "{error}");
assert_eq!(error["error"]["code"], "config_patch_not_atomic");
assert_eq!(std::fs::read(root).unwrap(), root_text.as_bytes());
assert_eq!(std::fs::read(&include).unwrap(), before);
patch(&fixture, "alice", json!({"source_deny":null})).await;
assert!(
!ProxyConfig::load(root)
.unwrap()
.access
.user_source_deny
.contains_key("alice")
);
assert!(
ProxyConfig::load(root)
.unwrap()
.access
.user_source_deny
.contains_key("bob")
);
}
#[tokio::test]
async fn source_deny_literal_username_supports_inline_dotted_and_quoted_sources() {
for declaration in [
"access.user_source_deny = { 'alice.two'=['192.0.2.0/24'], bob=['2001:db8::/32'] } # keep\n",
"access.user_source_deny.'alice.two'=['192.0.2.0/24']\naccess.user_source_deny.bob=['2001:db8::/32'] # keep\n",
"[access.user_source_deny]\n'alice.two'=['192.0.2.0/24']\nbob=['2001:db8::/32'] # keep\n",
] {
let fixture = fixture("");
let text = format!("{declaration}{}", USERS.replace("alice=", "'alice.two'="));
std::fs::write(&fixture.shared.config_path, text).unwrap();
patch(
&fixture,
"alice.two",
json!({"source_deny":["203.0.113.0/24"]}),
)
.await;
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert_eq!(cfg.access.user_source_deny.len(), 2);
assert_eq!(
cfg.access.user_source_deny["alice.two"][0].to_string(),
"203.0.113.0/24"
);
patch(&fixture, "alice.two", json!({"source_deny":null})).await;
let cfg = ProxyConfig::load(&fixture.shared.config_path).unwrap();
assert_eq!(cfg.access.user_source_deny.len(), 1);
assert_eq!(
cfg.access.user_source_deny["bob"][0].to_string(),
"2001:db8::/32"
);
assert!(
std::fs::read_to_string(&fixture.shared.config_path)
.unwrap()
.contains("# keep")
);
}
}
#[tokio::test]
async fn source_deny_invalid_values_and_stale_revision_leave_source_unchanged() {
let fixture = fixture("");
let before = std::fs::read(&fixture.shared.config_path).unwrap();
for value in [
json!("192.0.2.0/24"),
json!([1]),
json!(["192.0.2.0/33"]),
json!(["2001:db8::/129"]),
json!(["bad"]),
json!([null]),
] {
let (status, _, error) = fixture
.request_body(
"PATCH",
"/v1/users/alice",
true,
Some(&json!({"source_deny":value})),
&[],
)
.await;
assert_eq!(status, 400, "{error}");
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), before);
}
let (status, _, error) = fixture
.request_body(
"PATCH",
"/v1/users/alice",
true,
Some(&json!({"source_deny":[]})),
&[("If-Match", "stale")],
)
.await;
assert_eq!(status, 409, "{error}");
assert_eq!(error["error"]["code"], "revision_conflict");
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), before);
}
#[tokio::test]
async fn source_deny_prepared_reload_retains_old_rules_until_a_later_generation() {
let fixture = fixture("");
let (control, mut commands) = crate::maestro::reload::ReloadControl::channel(1);
let (accepted, _) = crate::api::submit_reload_from_disk(
&fixture.shared.config_path,
&fixture.shared.mutation_lock,
&control,
None,
crate::maestro::reload::ReloadRequest::default(),
)
.await
.unwrap();
let captured_for_reload = (*commands.recv().await.unwrap().config).clone();
let old_runtime = fixture.shared.active_runtime.load_full();
let admission = old_runtime.proxy_shared.clone();
let credential = credential_id_from_hex(&captured_for_reload.access.users["alice"]).unwrap();
let incarnation = admission
.stage_user_credential("alice", credential, true)
.incarnation;
let registration = admission
.register_authenticated_user_session("alice", credential)
.unwrap();
// The generation being prepared has already captured source before the API write.
let written = patch(&fixture, "alice", json!({"source_deny":["192.0.2.0/24"]})).await;
assert_ne!(written["revision"], accepted.config_revision);
assert!(!registration.is_cancelled());
assert_eq!(registration.incarnation(), incarnation);
let mut intermediate = captured_for_reload;
intermediate.server.api = old_runtime.config().server.api.clone();
fixture
.shared
.active_runtime
.store(test_runtime_generation(2, intermediate));
let (_, _, view) = fixture.request("GET", "/v1/users/alice", true).await;
assert_eq!(view["data"]["source_deny_status"]["effective"], json!([]));
assert_eq!(
view["data"]["source_deny_status"]["runtime_reload_required"],
true
);
publish(&fixture, 3);
let (_, _, view) = fixture.request("GET", "/v1/users/alice", true).await;
assert_eq!(
view["data"]["source_deny_status"]["runtime_reload_required"],
false
);
assert!(
!old_runtime
.config()
.access
.is_user_source_ip_denied("alice", "192.0.2.1".parse().unwrap())
);
assert!(!registration.is_cancelled());
}
#[tokio::test]
async fn source_deny_watcher_retains_rules_and_preserves_quota_usage() {
use crate::config::hot_reload::spawn_config_watcher;
use std::time::Duration;
use tokio::sync::watch;
let mut fixture = fixture(
"[server.api]\nenabled=true\nread_only=false\nauth_header='Bearer discovery-test'\n",
);
let config = fixture.shared.active_runtime.load().config();
let cancellation = tokio_util::sync::CancellationToken::new();
let _cancel_on_drop = cancellation.clone().drop_guard();
let (activation, activated) = watch::channel(false);
let (mut receiver, _, watcher) = spawn_config_watcher(
fixture.shared.config_path.clone(),
config.clone(),
None,
None,
cancellation.clone(),
None,
Some(activated),
Some(fixture.shared.mutation_lock.clone()),
None,
);
let mut runtime = test_runtime_generation(1, (*config).clone());
Arc::get_mut(&mut runtime).unwrap().config_rx = receiver.clone();
runtime.stats.load_user_quota_state("alice", 12345, 6789);
let stats = runtime.stats.clone();
let quota_path = fixture.shared.quota_state.path().to_path_buf();
Arc::get_mut(&mut fixture.shared).unwrap().quota_state =
crate::quota_state::QuotaStateOwner::new(quota_path.clone(), stats.quota_store());
let checkpoint_before = std::fs::read(&quota_path).ok();
fixture.shared.active_runtime.store(runtime);
let task = tokio::spawn(watcher);
patch(
&fixture,
"alice",
json!({"source_deny":["192.0.2.0/24"],"max_tcp_conns":7}),
)
.await;
activation.send_replace(true);
tokio::time::timeout(
Duration::from_secs(5),
receiver.wait_for(|cfg| cfg.access.user_max_tcp_conns.get("alice") == Some(&7)),
)
.await
.unwrap()
.unwrap();
assert!(receiver.borrow().access.user_source_deny.is_empty());
let (_, _, view) = fixture.request("GET", "/v1/users/alice", true).await;
assert_eq!(
view["data"]["source_deny_status"]["runtime_reload_required"],
true
);
assert_eq!(stats.get_user_quota_used("alice"), 12345);
assert_eq!(
stats.user_quota_snapshot()["alice"].last_reset_epoch_secs,
6789
);
assert_eq!(std::fs::read(&quota_path).ok(), checkpoint_before);
cancellation.cancel();
tokio::time::timeout(Duration::from_secs(5), task)
.await
.unwrap()
.unwrap();
}
+4 -2
View File
@@ -165,6 +165,7 @@ async fn patch_user_to_completion(
}
}
let source_deny_edits = apply_source_deny(&mut cfg, user, body.source_deny)?;
cfg.validate()
.map_err(|e| ApiFailure::bad_request(format!("config validation failed: {}", e)))?;
let staged_credential =
@@ -210,13 +211,14 @@ async fn patch_user_to_completion(
touched_sections.push(AccessSection::UserEnabled);
}
let revision = if touched_sections.is_empty() {
let revision = if touched_sections.is_empty() && source_deny_edits.is_empty() {
current_revision(&shared.config_path).await?
} else {
save_access_sections_to_disk_if_revision(
save_access_sections_and_fields_if_revision(
&shared.config_path,
&cfg,
&touched_sections,
source_deny_edits,
Some(&base_revision),
)
.await?
+83
View File
@@ -1,4 +1,64 @@
use super::*;
use crate::api::model::{InheritedLimit, SourceDenyState, UserLimitSnapshot, UserLimitState};
fn inherited_limit(configured_override: Option<usize>, global_value: usize) -> InheritedLimit {
let positive_override = configured_override.filter(|value| *value > 0);
InheritedLimit {
value: positive_override.or((global_value > 0).then_some(global_value)),
configured_override,
global_value,
origin: if positive_override.is_some() {
"user_override"
} else if global_value > 0 {
"global_default"
} else {
"unlimited"
},
}
}
fn limit_snapshot(cfg: &ProxyConfig, username: &str) -> UserLimitSnapshot {
UserLimitSnapshot {
max_tcp_conns: inherited_limit(
cfg.access.user_max_tcp_conns.get(username).copied(),
cfg.access.user_max_tcp_conns_global_each,
),
max_unique_ips: inherited_limit(
cfg.access.user_max_unique_ips.get(username).copied(),
cfg.access.user_max_unique_ips_global_each,
),
}
}
pub(in crate::api) fn refresh_runtime_view(user: &mut UserInfo, runtime: &ProxyConfig) {
user.in_runtime = runtime.access.users.contains_key(&user.username);
user.limits.effective = user
.in_runtime
.then(|| limit_snapshot(runtime, &user.username));
user.source_deny_status = source_deny_state(&user.username, &user.source_deny, Some(runtime));
}
fn source_deny_state(
username: &str,
desired: &[ipnetwork::IpNetwork],
runtime: Option<&ProxyConfig>,
) -> SourceDenyState {
// Retained rules can apply to a recreated user even before its membership is published.
let effective = runtime.map(|cfg| {
cfg.access
.user_source_deny
.get(username)
.cloned()
.unwrap_or_default()
});
SourceDenyState {
runtime_reload_required: effective.as_ref().map(|nets| nets.as_slice() != desired),
effective,
apply_mode: "generation_reload",
reload_endpoint: "POST /v1/system/reload",
effective_scope: "request_generation_snapshot",
}
}
pub(in crate::api) async fn users_from_config(
cfg: &ProxyConfig,
@@ -72,6 +132,29 @@ pub(in crate::api) async fn users_from_config(
.filter(|limit| *limit > 0)
.or((cfg.access.user_max_unique_ips_global_each > 0)
.then_some(cfg.access.user_max_unique_ips_global_each)),
limits: UserLimitState {
desired: limit_snapshot(cfg, &username),
effective: runtime_cfg
.filter(|runtime| runtime.access.users.contains_key(&username))
.map(|runtime| limit_snapshot(runtime, &username)),
effective_scope: "active_config_snapshot",
subsystem_convergence: "unknown",
},
source_deny: cfg
.access
.user_source_deny
.get(&username)
.cloned()
.unwrap_or_default(),
source_deny_status: source_deny_state(
&username,
cfg.access
.user_source_deny
.get(&username)
.map(Vec::as_slice)
.unwrap_or_default(),
runtime_cfg,
),
current_connections: stats.get_process_user_curr_connects(&username),
active_unique_ips: active_ip_list.len(),
active_unique_ips_list: active_ip_list,