use std::sync::Arc;
use serde_json::{Map, Value, json};
use url::Url;
use crate::envelope::Envelope;
use crate::error::Error;
use crate::links;
use crate::params;
use crate::routes::{self, ApiVersion, Resource};
use crate::transport::{RequestBody, Transport};
use crate::util::id_from_url;
const NETWORK_DNS_POLICY_KEYS: &[&str] = &["block_malware"];
fn validate_network_dns_policy_key(key: &str) -> Result<(), Error> {
if NETWORK_DNS_POLICY_KEYS.contains(&key) {
return Ok(());
}
Err(Error::validation(
"key",
format!(
"must be one of {}, got {}",
params::py_list(NETWORK_DNS_POLICY_KEYS),
params::py_quote(key)
),
))
}
fn payload(required: &[(&str, Value)], optional: &[(&str, Option<Value>)]) -> Value {
let mut map = Map::new();
for (key, value) in required {
map.insert((*key).to_owned(), value.clone());
}
for (key, value) in optional {
if let Some(value) = value {
map.insert((*key).to_owned(), value.clone());
}
}
Value::Object(map)
}
#[derive(Debug)]
pub struct DnsPoliciesApi {
transport: Arc<Transport>,
}
impl DnsPoliciesApi {
#[must_use]
pub fn new(transport: Arc<Transport>) -> Self {
Self { transport }
}
async fn put_policy(
&self,
route: &Resource,
network_id: &str,
parent: Option<&Value>,
operation: &str,
body: Value,
) -> Result<Envelope, Error> {
let url = route.resolve(self.transport.api_host(), network_id, parent)?;
links::warn_uncharacterised_write(operation);
self.transport
.request(route.method.clone(), url, &[], RequestBody::Json(body))
.await
}
fn network_route_url(
&self,
route: &Resource,
network_id: &str,
parent: Option<&Value>,
) -> Result<Url, Error> {
let base = params::resolve_network_url(
self.transport.api_host(),
network_id,
parent,
route.version,
)?;
let suffix = route
.template
.split_once("{id}")
.map_or("", |(_, suffix)| suffix);
Url::parse(&format!("{}{suffix}", base.as_str().trim_end_matches('/')))
.map_err(|err| Error::validation("url", format!("not a valid URL: {err}")))
}
async fn post_network_policy(
&self,
route: &Resource,
network_id: &str,
parent: Option<&Value>,
operation: &str,
body: Value,
) -> Result<Envelope, Error> {
let url = self.network_route_url(route, network_id, parent)?;
links::warn_uncharacterised_write(operation);
self.transport
.request(route.method.clone(), url, &[], RequestBody::Json(body))
.await
}
pub async fn get_advanced_content_filter(
&self,
network_id: &str,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.transport
.resource(
&routes::dns_policies::DNS_POLICIES_GET_ADVANCED_CONTENT_FILTER,
network_id,
parent,
&[],
RequestBody::None,
)
.await
}
#[allow(clippy::too_many_arguments)] pub async fn allow_domain(
&self,
network_id: &str,
domain: &str,
add_cname: Option<bool>,
reason_to_allow: Option<i64>,
is_delete: Option<bool>,
keep_profiles: Option<&[&str]>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let body = payload(
&[("domain", Value::String(domain.to_owned()))],
&[
("add_cname", add_cname.map(Value::Bool)),
("reason_to_allow", reason_to_allow.map(Into::into)),
("is_delete", is_delete.map(Value::Bool)),
("keep_profiles", keep_profiles.map(to_string_array)),
],
);
self.put_policy(
&routes::dns_policies::DNS_POLICIES_ALLOW_DOMAIN,
network_id,
parent,
"allow domain for network",
body,
)
.await
}
pub async fn allow_cnames(
&self,
network_id: &str,
domains: &[&str],
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_policy(
&routes::dns_policies::DNS_POLICIES_ALLOW_CNAMES,
network_id,
parent,
"allow CNAMEs for network",
json!({ "domains": domains }),
)
.await
}
pub async fn block_domain(
&self,
network_id: &str,
domain: &str,
is_delete: Option<bool>,
keep_profiles: Option<&[&str]>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let body = payload(
&[("domain", Value::String(domain.to_owned()))],
&[
("is_delete", is_delete.map(Value::Bool)),
("keep_profiles", keep_profiles.map(to_string_array)),
],
);
self.put_policy(
&routes::dns_policies::DNS_POLICIES_BLOCK_DOMAIN,
network_id,
parent,
"block domain for network",
body,
)
.await
}
#[allow(clippy::too_many_arguments)] pub async fn allow_domain_for_profiles(
&self,
network_id: &str,
domain: &str,
profiles: &[&str],
override_: Option<bool>,
add_cname: Option<bool>,
reason_to_allow: Option<i64>,
is_delete: Option<bool>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let body = payload(
&[
("domain", Value::String(domain.to_owned())),
("profiles", to_string_array(profiles)),
],
&[
("override", override_.map(Value::Bool)),
("add_cname", add_cname.map(Value::Bool)),
("reason_to_allow", reason_to_allow.map(Into::into)),
("is_delete", is_delete.map(Value::Bool)),
],
);
self.put_policy(
&routes::dns_policies::DNS_POLICIES_ALLOW_DOMAIN_FOR_PROFILES,
network_id,
parent,
"allow domain for profiles on network",
body,
)
.await
}
pub async fn allow_cnames_for_profiles(
&self,
network_id: &str,
domains: &[&str],
profiles: &[&str],
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.put_policy(
&routes::dns_policies::DNS_POLICIES_ALLOW_CNAMES_FOR_PROFILES,
network_id,
parent,
"allow CNAMEs for profiles on network",
json!({ "domains": domains, "profiles": profiles }),
)
.await
}
pub async fn block_domain_for_profiles(
&self,
network_id: &str,
domain: &str,
profiles: &[&str],
is_delete: Option<bool>,
override_: Option<bool>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let body = payload(
&[
("domain", Value::String(domain.to_owned())),
("profiles", to_string_array(profiles)),
],
&[
("is_delete", is_delete.map(Value::Bool)),
("override", override_.map(Value::Bool)),
],
);
self.put_policy(
&routes::dns_policies::DNS_POLICIES_BLOCK_DOMAIN_FOR_PROFILES,
network_id,
parent,
"block domain for profiles on network",
body,
)
.await
}
pub async fn get_profile_applications(
&self,
network_id: &str,
profile_id: &str,
) -> Result<Envelope, Error> {
let child = id_from_url(profile_id)?;
self.transport
.nested(
&routes::dns_policies::DNS_POLICIES_GET_PROFILE_APPLICATIONS,
network_id,
&child,
None,
&[],
RequestBody::None,
)
.await
}
pub async fn set_profile_blocked_applications(
&self,
network_id: &str,
profile_id: &str,
applications: &[&str],
) -> Result<Envelope, Error> {
let child = id_from_url(profile_id)?;
let url = routes::dns_policies::DNS_POLICIES_SET_PROFILE_BLOCKED_APPLICATIONS.resolve(
self.transport.api_host(),
network_id,
&child,
None,
)?;
links::warn_uncharacterised_write("set blocked applications for profile on network");
self.transport
.request(
routes::dns_policies::DNS_POLICIES_SET_PROFILE_BLOCKED_APPLICATIONS
.method
.clone(),
url,
&[],
RequestBody::Json(json!({ "applications": applications })),
)
.await
}
fn profile_paths(&self, network_id: &str, profiles: &[&str]) -> Result<Vec<String>, Error> {
profiles
.iter()
.map(|profile| {
params::resolve_nested_url(
self.transport.api_host(),
network_id,
profile,
"profiles",
"",
None,
None,
ApiVersion::V2_2,
)
.map(|url| url.path().to_owned())
})
.collect()
}
pub async fn set_network_ad_block(
&self,
network_id: &str,
enabled: bool,
profiles: Option<&[&str]>,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
let mut body = Map::new();
body.insert("enable".to_owned(), Value::Bool(enabled));
if let Some(profiles) = profiles {
body.insert(
"profiles".to_owned(),
to_string_array_owned(&self.profile_paths(network_id, profiles)?),
);
}
self.post_network_policy(
&routes::dns_policies::DNS_POLICIES_SET_NETWORK_AD_BLOCK,
network_id,
parent,
"set network ad block for network",
Value::Object(body),
)
.await
}
async fn set_network_dns_policy(
&self,
network_id: &str,
key: &str,
value: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
validate_network_dns_policy_key(key)?;
self.post_network_policy(
&routes::dns_policies::DNS_POLICIES_SET_NETWORK_POLICY,
network_id,
parent,
&format!("set network DNS policy {key} for network"),
json!({ key: value }),
)
.await
}
pub async fn set_network_block_malware(
&self,
network_id: &str,
enabled: bool,
parent: Option<&Value>,
) -> Result<Envelope, Error> {
self.set_network_dns_policy(network_id, "block_malware", enabled, parent)
.await
}
}
fn to_string_array_owned(values: &[String]) -> Value {
Value::Array(values.iter().cloned().map(Value::String).collect())
}
fn to_string_array(values: &[&str]) -> Value {
Value::Array(
values
.iter()
.map(|v| Value::String((*v).to_owned()))
.collect(),
)
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use super::{DnsPoliciesApi, validate_network_dns_policy_key};
use crate::error::Error;
use crate::transport::Transport;
#[test]
fn the_only_network_dns_policy_key_is_block_malware() {
assert!(validate_network_dns_policy_key("block_malware").is_ok());
}
#[test]
fn an_unknown_network_dns_policy_key_is_rejected_with_pythons_message() {
let Err(Error::Validation { field, message, .. }) =
validate_network_dns_policy_key("block_malwre")
else {
panic!("a misspelt key must be a validation error");
};
assert_eq!(field, "key");
assert_eq!(
message,
"must be one of ['block_malware'], got 'block_malwre'"
);
}
#[tokio::test]
async fn set_network_dns_policy_rejects_an_unknown_key_before_any_request() {
let transport = Transport::builder()
.base_url("http://mock.test:1")
.build()
.expect("a literal http base url is valid");
let api = DnsPoliciesApi::new(Arc::new(transport));
let err = api
.set_network_dns_policy("network-0001", "block_malwre", true, None)
.await
.expect_err("an unknown key must be rejected");
assert!(
matches!(&err, Error::Validation { field, .. } if field == "key"),
"{err:?}"
);
}
}