API: add scoped DNS overrides management

This commit is contained in:
Alexey
2026-11-05 20:00:28 +03:00
parent 55e7b16ec3
commit 4ff565193f
9 changed files with 606 additions and 21 deletions
+420
View File
@@ -0,0 +1,420 @@
use super::*;
use crate::api::discovery::http_tests::Fixture;
use crate::config::hot_reload::spawn_config_watcher;
use crate::maestro::generation::test_runtime_generation;
use crate::network::dns_overrides::GenerationDnsResolver;
use serde_json::json;
use std::time::Duration;
use tokio::sync::watch;
use tokio_util::sync::CancellationToken;
const OLD: &str = "old.example:443:192.0.2.1";
const NEW: &str = "new.example:443:192.0.2.2";
fn patch(entries: Json) -> Json {
json!({"network": {"dns_overrides": entries}})
}
#[tokio::test]
async fn get_exposes_only_dns_overrides_including_the_empty_default() {
for entries in [vec![], vec![OLD.to_owned()]] {
let source = format!(
"[network]\nipv4 = true\ncache_public_ip_path = 'private-path'\ndns_overrides = {}\n",
json!(entries)
);
let (path, _directory) = tests::temp_config(&source);
let (managed, _) = read_managed_config(&path).await.unwrap();
assert_eq!(
serde_json::to_value(&managed["network"]).unwrap(),
patch(json!(entries))["network"]
);
assert!(
!serde_json::to_string(&managed)
.unwrap()
.contains("private-path")
);
}
let (path, _directory) = tests::temp_config("");
let (managed, _) = read_managed_config(&path).await.unwrap();
assert_eq!(
serde_json::to_value(&managed["network"]).unwrap(),
json!({"dns_overrides": []})
);
}
#[tokio::test]
async fn every_network_sibling_is_rejected_even_as_null_without_writing() {
let (path, _directory) = tests::temp_config("[network]\nipv4 = true\n");
let original = std::fs::read(&path).unwrap();
let network = serde_json::to_value(ProxyConfig::default().network).unwrap();
for (key, value) in network.as_object().unwrap() {
if key == "dns_overrides" {
continue;
}
for value in [value.clone(), Json::Null] {
let body = json!({"network": {key: value, "dns_overrides": [NEW]}});
let error = apply_patch_to_path(&path, &body, None).await.unwrap_err();
assert_eq!(error.code, "field_not_editable", "{key}: {error:?}");
assert_eq!(std::fs::read(&path).unwrap(), original);
}
}
for value in [
json!([]),
json!("bad"),
json!({}),
json!({"dns_overrides": null}),
json!({"typo": []}),
] {
assert!(
apply_patch_to_path(&path, &json!({"network": value}), None)
.await
.is_err()
);
assert_eq!(std::fs::read(&path).unwrap(), original);
}
}
#[tokio::test]
async fn malformed_dns_arrays_never_change_source_or_revision() {
let (path, _directory) = tests::temp_config(&format!("[network]\ndns_overrides = ['{OLD}']\n"));
let original = std::fs::read(&path).unwrap();
let revision = super::super::config_store::current_revision(&path)
.await
.unwrap();
for entries in [
json!(NEW),
json!([12]),
json!([""]),
json!(["host:443:bad-ip"]),
json!(["host:65536:192.0.2.1"]),
json!([":443:192.0.2.1"]),
json!(["host:443:2001:db8::1"]),
json!([null]),
json!(vec![OLD; 4097]),
] {
let error = apply_patch_to_path(&path, &patch(entries), None)
.await
.unwrap_err();
assert_eq!(error.status, hyper::StatusCode::BAD_REQUEST);
assert_eq!(std::fs::read(&path).unwrap(), original);
assert_eq!(
super::super::config_store::current_revision(&path)
.await
.unwrap(),
revision
);
}
}
#[tokio::test]
async fn add_replace_and_clear_preserve_unrelated_source_bytes() {
let sources = [
"# root without network\n[general]\nlog_level = 'normal'\n".to_owned(),
"[network] # identity\nipv4 = true # keep\n[general]\nlog_level = 'normal'\n".to_owned(),
"network = { ipv4 = true } # keep\n[general]\nlog_level = 'normal'\n".to_owned(),
"network = {}\n".to_owned(),
"network.ipv4 = true # keep\n[general]\nlog_level = 'normal'\n".to_owned(),
"['network'] # quoted\nipv4 = true\n".to_owned(),
"[network] # no final newline".to_owned(),
"[network]\r\nipv4 = true # keep\r\n".to_owned(),
];
for source in sources {
let (path, _directory) = tests::temp_config(&source);
let initial_network = ProxyConfig::load(&path).unwrap().network;
for entries in [
json!([OLD, "v6.example:8443:[2001:db8::1]"]),
json!([NEW]),
json!([]),
] {
let (before, revision) = read_managed_config(&path).await.unwrap();
let response = apply_patch_to_path(&path, &patch(entries.clone()), Some(revision))
.await
.unwrap();
assert!(!response.restart_required);
assert!(!response.process_restart_required);
assert_eq!(response.changed, ["network"]);
let expected_paths = if entries == json!([]) {
vec!["network.dns_overrides[0]"]
} else {
vec!["network.dns_overrides[0]", "network.dns_overrides[1]"]
};
assert_eq!(response.changed_paths, expected_paths);
let (managed, revision) = read_managed_config(&path).await.unwrap();
assert_eq!(
serde_json::to_value(&managed["network"]["dns_overrides"]).unwrap(),
entries
);
assert_eq!(response.revision, revision);
assert_eq!(managed["general"], before["general"]);
let mut network = ProxyConfig::load(&path).unwrap().network;
network.dns_overrides = initial_network.dns_overrides.clone();
assert_eq!(
serde_json::to_value(network).unwrap(),
serde_json::to_value(&initial_network).unwrap()
);
}
let written = std::fs::read_to_string(&path).unwrap();
// New declarations can be inserted, but every original line survives.
for line in source.lines() {
if line.starts_with("network = {") {
assert!(
written.contains(&line.replace("{", "{dns_overrides = [], "))
|| written.contains(&line.replace("{}", "{dns_overrides = []}")),
"{written}"
);
} else {
assert!(written.contains(line), "{source:?}: {written}");
}
}
}
}
#[tokio::test]
async fn replacement_uses_parser_spans_for_multiline_dotted_and_inline_values() {
let old_value = format!("[\n '{OLD}', # replace only this value\n]");
for (prefix, value, suffix) in [
(
"# Unicode: ü\n[network]\n\"dns_overrides\" = ",
old_value.as_str(),
" # trailing\nipv4=true\n",
),
(
"network = { ipv4=true, dns_overrides=",
"['old.example:443:192.0.2.1']",
" } # trailing\n",
),
(
"'network'.'dns_overrides' = ",
"['old.example:443:192.0.2.1']",
"\nnetwork.ipv4=true\n",
),
] {
let source = format!("{prefix}{value}{suffix}");
let (path, _directory) = tests::temp_config(&source);
apply_patch_to_path(&path, &patch(json!([NEW])), None)
.await
.unwrap();
let written = std::fs::read_to_string(&path).unwrap();
assert_eq!(written, format!("{prefix}[\"{NEW}\"]{suffix}"));
}
}
#[tokio::test]
async fn included_parent_owns_new_dns_key_and_leaf_owner_precedes_other_network_fields() {
for existing in [false, true] {
let directory = tempfile::tempdir().unwrap();
let root = directory.path().join("config.toml");
let included = directory.path().join("network.toml");
let root_text = if existing {
"include = \"network.toml\"\nnetwork.ipv4 = true # keep root identity\n[general]\nlog_level='normal'\n"
} else {
"include = \"network.toml\"\n[general]\nlog_level='normal'\n"
};
let included_text = if existing {
format!("network.dns_overrides = ['{OLD}'] # retain\n")
} else {
"[network] # retain\nipv4 = true # identity\n".to_owned()
};
std::fs::write(&root, root_text).unwrap();
std::fs::write(&included, &included_text).unwrap();
for entries in [json!([NEW]), json!([])] {
apply_patch_to_path(&root, &patch(entries.clone()), None)
.await
.unwrap();
assert_eq!(std::fs::read_to_string(&root).unwrap(), root_text);
assert_eq!(
serde_json::to_value(ProxyConfig::load(&root).unwrap().network.dns_overrides)
.unwrap(),
entries
);
let written = std::fs::read_to_string(&included).unwrap();
assert!(written.contains("# retain"));
if !existing {
assert!(written.contains("ipv4 = true # identity"));
}
}
}
}
#[tokio::test]
async fn cross_source_and_ambiguous_parent_edits_are_atomic_rejections() {
for (root_text, included_text, body) in [
(
"include = \"network.toml\"\n[censorship]\ntls_domain='old.example'\n".to_owned(),
format!("[network]\ndns_overrides=['{OLD}']\n"),
json!({"network":{"dns_overrides":[NEW]},"censorship":{"tls_domain":"new.example"}}),
),
(
"include = \"network.toml\"\nnetwork.ipv4 = true\n".to_owned(),
"network.stun_use = false\n".to_owned(),
patch(json!([NEW])),
),
] {
let directory = tempfile::tempdir().unwrap();
let root = directory.path().join("config.toml");
let included = directory.path().join("network.toml");
std::fs::write(&root, &root_text).unwrap();
std::fs::write(&included, &included_text).unwrap();
let error = apply_patch_to_path(&root, &body, None).await.unwrap_err();
assert_eq!(error.code, "config_patch_not_atomic");
assert_eq!(std::fs::read_to_string(&root).unwrap(), root_text);
assert_eq!(std::fs::read_to_string(&included).unwrap(), included_text);
}
}
#[tokio::test]
async fn prepared_dns_patch_retains_source_revision_fencing() {
let (path, _directory) = tests::temp_config(&format!("[network]\ndns_overrides=['{OLD}']\n"));
let prepared = prepare_patch_to_path(&path, &patch(json!([NEW])), None)
.await
.unwrap();
let external = "[network]\ndns_overrides=[]\n# external edit\n";
std::fs::write(&path, external).unwrap();
let error = write_atomic_if_unchanged(
prepared.config_path,
prepared.expected_revision,
prepared.owner_path,
prepared.expected_owner_contents,
prepared.owner_contents,
)
.await
.unwrap_err();
assert_eq!(error.code, "revision_conflict");
assert_eq!(std::fs::read_to_string(&path).unwrap(), external);
}
#[tokio::test]
async fn http_preflight_commit_and_watcher_update_future_generation_resolutions() {
let fixture = Fixture::new(false);
let source = "[network]\nipv4 = true # retain\n[server.api]\nenabled=true\nread_only=false\nauth_header='Bearer discovery-test'\n";
std::fs::write(&fixture.shared.config_path, source).unwrap();
let config = Arc::new(
ProxyConfig::load_prepared(fixture.shared.config_path.clone())
.await
.unwrap()
.config,
);
let resolver = Arc::new(GenerationDnsResolver::from_entries(&[]).unwrap());
let cancellation = CancellationToken::new();
let _cancel_on_drop = cancellation.clone().drop_guard();
let (activation, activated) = watch::channel(false);
let (mut receiver, _log_receiver, watcher) = spawn_config_watcher(
fixture.shared.config_path.clone(),
config.clone(),
None,
None,
cancellation.clone(),
Some(resolver.clone()),
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();
fixture.shared.active_runtime.store(runtime);
let task = tokio::spawn(watcher);
for entries in [
json!([OLD]),
json!([NEW, "v6.example:8443:[2001:db8::1]"]),
json!([]),
] {
let body = patch(entries.clone());
let before = std::fs::read(&fixture.shared.config_path).unwrap();
let preview = fixture
.request_body("POST", "/v1/config/validate", true, Some(&body), &[])
.await;
assert_eq!(preview.0, 200, "{}", preview.2);
let data = &preview.2["data"];
let expected_paths = if entries == json!([OLD]) {
json!(["network.dns_overrides[0]"])
} else {
json!(["network.dns_overrides[0]", "network.dns_overrides[1]"])
};
assert_eq!(data["apply"]["watcher_paths"], expected_paths);
assert_eq!(data["changed_paths"], expected_paths);
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), before);
let response = fixture
.request_body(
"PATCH",
"/v1/config",
true,
Some(&body),
&[
("If-Match", data["base_revision"].as_str().unwrap()),
(
"If-Runtime-Match",
data["runtime"]["runtime_match"].as_str().unwrap(),
),
],
)
.await;
assert_eq!(response.0, 200, "{}", response.2);
assert_eq!(response.2["data"]["restart_required"], false);
assert_eq!(response.2["data"]["process_restart_required"], false);
activation.send_replace(true);
let wanted: Vec<String> = serde_json::from_value(entries.clone()).unwrap();
tokio::time::timeout(
Duration::from_secs(5),
receiver.wait_for(|config| config.network.dns_overrides == wanted),
)
.await
.unwrap()
.unwrap();
assert_eq!(
resolver.resolve_socket_addr("OLD.EXAMPLE", 443),
if entries == json!([OLD]) {
Some("192.0.2.1:443".parse().unwrap())
} else {
None
}
);
assert_eq!(
resolver.resolve_socket_addr("new.example", 443),
if wanted.iter().any(|entry| entry == NEW) {
Some("192.0.2.2:443".parse().unwrap())
} else {
None
}
);
assert_eq!(
resolver.resolve_socket_addr("v6.example", 8443),
if wanted.len() == 2 {
Some("[2001:db8::1]:8443".parse().unwrap())
} else {
None
}
);
assert!(resolver.resolve_socket_addr("new.example", 444).is_none());
let get = fixture.request("GET", "/v1/config", true).await;
assert_eq!(get.0, 200);
assert_eq!(get.2["data"]["network"], body["network"]);
assert!(fixture.shared.reload_control.in_progress().await.is_none());
let current = std::fs::read(&fixture.shared.config_path).unwrap();
for invalid in [
patch(json!(["invalid"])),
json!({"network":{"ipv4":false,"dns_overrides":[]}}),
] {
for method in ["POST", "PATCH"] {
let route = if method == "POST" {
"/v1/config/validate"
} else {
"/v1/config"
};
assert_eq!(
fixture
.request_body(method, route, true, Some(&invalid), &[])
.await
.0,
400
);
assert_eq!(std::fs::read(&fixture.shared.config_path).unwrap(), current);
}
}
}
cancellation.cancel();
tokio::time::timeout(Duration::from_secs(5), task)
.await
.unwrap()
.unwrap();
}
+8 -1
View File
@@ -69,7 +69,7 @@ fn parse_patch(
));
}
// 2. convert + reject access / unknown sections / forbidden server fields
// 2. Reject access, unknown sections and forbidden partial-section fields.
let mut patch_toml = json_to_toml(patch_json)
.map_err(|e| ApiFailure::bad_request(format!("invalid patch: {}", e)))?;
let patch_table = patch_toml
@@ -92,6 +92,8 @@ fn parse_patch(
}
if key == "server" {
validate_server_patch(value)?;
} else if key == "network" {
validate_network_patch(&patch_json["network"])?;
}
}
let touched: Vec<String> = patch_table
@@ -130,6 +132,8 @@ fn parse_patch(
.map(|section| {
if section == "server" {
"server.listeners"
} else if section == "network" {
"network.dns_overrides"
} else {
section.as_str()
}
@@ -147,6 +151,9 @@ fn parse_patch(
if *section == "server" {
let rendered = render_server_listeners(&requested_cfg)?;
owner_contents = upsert_toml_table(&owner_contents, "server.listeners", &rendered);
} else if *section == "network" {
owner_contents =
upsert_dns_overrides(&owner_contents, &requested_cfg.network.dns_overrides)?;
} else {
let rendered = render_top_level_section(&requested_cfg, section)?;
owner_contents = upsert_toml_table(&owner_contents, section, &rendered);
+6 -3
View File
@@ -73,7 +73,7 @@ fn deep_merge_overlays_tables_and_replaces_scalars() {
use std::path::PathBuf;
fn temp_config(body: &str) -> (PathBuf, tempfile::TempDir) {
pub(super) fn temp_config(body: &str) -> (PathBuf, tempfile::TempDir) {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("config.toml");
std::fs::write(&path, body).unwrap();
@@ -228,7 +228,7 @@ async fn invalid_web_patch_does_not_modify_the_source() {
#[tokio::test]
async fn read_managed_config_returns_only_editable_sections() {
// Full server (api/port) and network must not leak. Listeners-only server
// Server identity and network siblings must not leak. Listeners-only server
// is returned via the nested allowlist (covered in a dedicated test).
let (path, _d) = temp_config(concat!(
"[censorship]\ntls_domain = \"a\"\n",
@@ -243,7 +243,10 @@ async fn read_managed_config_returns_only_editable_sections() {
assert!(server.contains_key("listeners"));
assert!(!server.contains_key("api"));
assert!(!server.contains_key("port"));
assert!(!table.contains_key("network"));
assert_eq!(
serde_json::to_value(&table["network"]).unwrap(),
serde_json::json!({"dns_overrides": []})
);
assert!(!table.contains_key("access"));
}