cloud_dns/api/
policies.rs

1use serde::{Deserialize, Serialize};
2
3use crate::{DnsClient, Result};
4
5use super::{ListEnvelope, UpdateEnvelope};
6
7#[derive(Serialize, Deserialize, Debug)]
8#[serde(rename_all = "camelCase")]
9pub struct Policy {
10    pub kind: String, // "dns#policy"
11    pub id: u64,
12    pub name: String,
13    pub enable_inbound_forwarding: bool,
14    pub description: String,
15    pub networks: PolicyNetwork,
16    pub alternative_name_server_config: AlternativeNameServerConfig,
17    pub enable_logging: bool,
18}
19
20#[derive(Serialize, Deserialize, Debug)]
21#[serde(rename_all = "camelCase")]
22pub struct PolicyNetwork {
23    pub kind: String, // "dns#policyNetwork"
24    pub network_url: String,
25}
26
27#[derive(Serialize, Deserialize, Debug)]
28#[serde(rename_all = "camelCase")]
29pub struct AlternativeNameServerConfig {
30    pub kind: String, // "dns#policyAlternativeNameServerConfig"
31    pub target_name_servers: Vec<AlternativeNameServerConfigTargetNameServers>,
32}
33
34#[derive(Serialize, Deserialize, Debug)]
35#[serde(rename_all = "camelCase")]
36pub struct AlternativeNameServerConfigTargetNameServers {
37    pub kind: String, // "dns#policyAlternativeNameServerConfigTargetNameServer"
38    pub ipv4_address: String,
39    pub forwarding_path: String,
40}
41
42#[derive(Serialize, Deserialize, Debug)]
43#[serde(rename_all = "camelCase")]
44pub struct Policies {
45    #[serde(flatten)]
46    pub envelope: ListEnvelope,
47    pub policies: Vec<Policy>,
48}
49
50#[derive(Serialize, Deserialize, Debug)]
51#[serde(rename_all = "camelCase")]
52pub struct UpdatePolicy {
53    #[serde(flatten)]
54    pub envelope: UpdateEnvelope,
55    pub policy: Policy,
56}
57
58pub struct PoliciesHandler<'client> {
59    client: &'client DnsClient,
60}
61
62impl<'client> PoliciesHandler<'client> {
63    pub(crate) fn new(client: &'client DnsClient) -> Self {
64        Self { client }
65    }
66
67    pub async fn list(&self) -> Result<Policies> {
68        let route = "policies".to_string();
69
70        self.client.get(route).await
71    }
72
73    pub async fn get(&self, policy: &str) -> Result<Policy> {
74        let route = format!("policies/{policy}", policy = policy,);
75
76        self.client.get(route).await
77    }
78
79    pub async fn patch(&self, policy_id: &str, policy: Policy) -> Result<Policy> {
80        let route = format!("policies/{policy_id}", policy_id = policy_id,);
81
82        self.client.patch(route, Some(&policy)).await
83    }
84
85    pub async fn create(&self, policy: Policy) -> Result<Policy> {
86        let route = "policies".to_string();
87
88        self.client.post(route, Some(&policy)).await
89    }
90
91    pub async fn delete(&self, policy_id: &str) -> Result<()> {
92        let route = format!("policies/{policy_id}", policy_id = policy_id,);
93
94        self.client.delete(route).await
95    }
96
97    pub async fn update(&self, policy_id: &str, policy: Policy) -> Result<UpdatePolicy> {
98        let route = format!("policies/{policy_id}", policy_id = policy_id,);
99
100        self.client.put(route, Some(&policy)).await
101    }
102}