dnsync 0.2.2

DNS Sync and Control with MCP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use rmcp::{ErrorData as McpError, model::*};

use crate::{
    control_plane::policy::Policy,
    core::dns::service::DnsService,
    core::dns::zones,
    mcp::{
        helpers::{run_json, run_text},
        params::*,
    },
};

pub async fn handle_list_zones<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ListZonesParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_json(
        "dns_list_zones",
        policy.check_read(),
        zones::list_zones(
            client,
            p.page_number.unwrap_or(1),
            p.zones_per_page.unwrap_or(50),
        ),
    )
    .await)
}

pub async fn handle_create_zone<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: CreateZoneParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_json(
        "dns_create_zone",
        policy.check_write().and(policy.check_zone(&p.zone)),
        zones::create_zone(client, &p.zone, &p.zone_type),
    )
    .await)
}

pub async fn handle_delete_zone<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ZoneParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_json(
        "dns_delete_zone",
        policy.check_delete().and(policy.check_zone(&p.zone)),
        zones::delete_zone(client, &p.zone),
    )
    .await)
}

pub async fn handle_enable_zone<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ZoneParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_json(
        "dns_enable_zone",
        policy.check_write().and(policy.check_zone(&p.zone)),
        zones::enable_zone(client, &p.zone),
    )
    .await)
}

pub async fn handle_disable_zone<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ZoneParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_json(
        "dns_disable_zone",
        policy.check_write().and(policy.check_zone(&p.zone)),
        zones::disable_zone(client, &p.zone),
    )
    .await)
}

pub async fn handle_import_zone_file<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ImportZoneFileParams,
) -> Result<CallToolResult, McpError> {
    let file_name = p.file_name.unwrap_or_else(|| format!("{}.txt", p.zone));
    Ok(run_json(
        "dns_import_zone_file",
        policy.check_write().and(policy.check_zone(&p.zone)),
        zones::import_zone_file(
            client,
            &p.zone,
            file_name,
            p.content.into_bytes(),
            p.options.overwrite,
            p.options.overwrite_zone,
            p.options.overwrite_soa_serial,
        ),
    )
    .await)
}

pub async fn handle_export_zone_file<C: DnsService + Send + Sync>(
    client: &C,
    policy: &Policy,
    p: ExportZoneFileParams,
) -> Result<CallToolResult, McpError> {
    Ok(run_text(
        "dns_export_zone_file",
        policy.check_read().and(policy.check_zone(&p.zone)),
        zones::export_zone_file(client, &p.zone),
    )
    .await)
}