netweft 0.2.0

Deterministic network planning and configuration generation for portable infrastructure.
Documentation
use std::fs;
use std::path::{Path, PathBuf};

use anyhow::{Context, Result, bail};

use crate::plan::dns::{ResolvedDnsPlan, ResolvedRecord, ResolvedReverseZone, ResolvedZone};

pub fn render_bind(plan: &ResolvedDnsPlan, output: &Path) -> Result<PathBuf> {
    let parent = output
        .parent()
        .context("BIND output directory has no parent")?;
    fs::create_dir_all(parent)?;

    let temp = parent.join(format!(".bind-{}.tmp", std::process::id()));
    if temp.exists() {
        fs::remove_dir_all(&temp)?;
    }

    fs::create_dir_all(temp.join("zones"))?;

    write(&temp.join("named.conf"), &render_named_conf())?;
    write(
        &temp.join("named.conf.options"),
        &render_named_conf_options(plan),
    )?;
    write(
        &temp.join("named.conf.local"),
        &render_named_conf_local(plan),
    )?;

    for zone in &plan.zones {
        write(
            &temp.join("zones").join(zone_filename(&zone.name)),
            &render_forward_zone(plan, zone),
        )?;
    }

    for zone in &plan.reverse_zones {
        write(
            &temp.join("zones").join(zone_filename(&zone.name)),
            &render_reverse_zone(plan, zone),
        )?;
    }

    write(&temp.join("manifest.txt"), &render_manifest(plan))?;

    if output.exists() {
        fs::remove_dir_all(output)
            .with_context(|| format!("failed to replace {}", output.display()))?;
    }

    fs::rename(&temp, output).with_context(|| {
        format!(
            "failed to move rendered BIND tree from {} to {}",
            temp.display(),
            output.display()
        )
    })?;

    Ok(output.to_path_buf())
}

fn render_named_conf() -> String {
    [
        "// Generated by Netweft. Do not edit.",
        "",
        "include \"/etc/bind/named.conf.options\";",
        "include \"/etc/bind/named.conf.local\";",
        "",
    ]
    .join("\n")
}

fn render_named_conf_options(plan: &ResolvedDnsPlan) -> String {
    let mut out = String::new();
    out.push_str("// Generated by Netweft. Do not edit.\n\n");
    out.push_str("acl \"netweft-recursion-clients\" {\n");

    for network in &plan.access.ipv4 {
        out.push_str(&format!("    {network};\n"));
    }
    for network in &plan.access.ipv6 {
        out.push_str(&format!("    {network};\n"));
    }

    out.push_str("};\n\n");
    out.push_str("options {\n");
    out.push_str("    directory \"/var/cache/bind\";\n\n");
    out.push_str("    listen-on { any; };\n");
    out.push_str("    listen-on-v6 { any; };\n\n");
    out.push_str("    recursion yes;\n");
    out.push_str("    allow-query { netweft-recursion-clients; };\n");
    out.push_str("    allow-recursion { netweft-recursion-clients; };\n");
    out.push_str("    allow-query-cache { netweft-recursion-clients; };\n\n");
    out.push_str("    forward only;\n");
    out.push_str("    forwarders {\n");

    for address in &plan.forwarders_ipv4 {
        out.push_str(&format!("        {address};\n"));
    }
    for address in &plan.forwarders_ipv6 {
        out.push_str(&format!("        {address};\n"));
    }

    out.push_str("    };\n\n");
    out.push_str("    dnssec-validation auto;\n");
    out.push_str("    auth-nxdomain no;\n");
    out.push_str("};\n");
    out
}

fn render_named_conf_local(plan: &ResolvedDnsPlan) -> String {
    let mut out = String::from("// Generated by Netweft. Do not edit.\n\n");

    for zone in &plan.zones {
        out.push_str(&render_zone_declaration(&zone.name));
    }
    for zone in &plan.reverse_zones {
        out.push_str(&render_zone_declaration(&zone.name));
    }

    out
}

fn render_zone_declaration(zone: &str) -> String {
    format!(
        "zone \"{zone}\" {{\n    type primary;\n    file \"/etc/bind/zones/{}\";\n    allow-update {{ none; }};\n    allow-transfer {{ none; }};\n}};\n\n",
        zone_filename(zone)
    )
}

fn render_forward_zone(plan: &ResolvedDnsPlan, zone: &ResolvedZone) -> String {
    let mut out = zone_header(plan, &zone.name);

    for record in &zone.records {
        match record {
            ResolvedRecord::A { name, address } => {
                out.push_str(&format!("{name:<44} IN A     {address}\n"));
            }
            ResolvedRecord::Aaaa { name, address } => {
                out.push_str(&format!("{name:<44} IN AAAA  {address}\n"));
            }
            ResolvedRecord::Cname { name, target } => {
                out.push_str(&format!("{name:<44} IN CNAME {target}\n"));
            }
            ResolvedRecord::Ns { name, target } => {
                out.push_str(&format!("{name:<44} IN NS    {target}\n"));
            }
        }
    }

    out
}

fn render_reverse_zone(plan: &ResolvedDnsPlan, zone: &ResolvedReverseZone) -> String {
    let mut out = zone_header(plan, &zone.name);

    out.push_str(&format!(
        "{:<44} IN NS    {}\n",
        zone_fqdn(&zone.name),
        plan.soa_primary_nameserver
    ));

    for (owner, target) in &zone.records {
        out.push_str(&format!("{owner:<44} IN PTR   {target}\n"));
    }

    out
}

fn zone_header(plan: &ResolvedDnsPlan, zone: &str) -> String {
    format!(
        "; Generated by Netweft. Do not edit.\n\
$TTL {}\n\
$ORIGIN {}.\n\
@ IN SOA {} {} (\n\
    1\n\
    {}\n\
    {}\n\
    {}\n\
    {}\n\
)\n\n",
        plan.default_ttl,
        zone.trim_end_matches('.'),
        plan.soa_primary_nameserver,
        plan.soa_responsible_mailbox,
        plan.soa_refresh,
        plan.soa_retry,
        plan.soa_expire,
        plan.negative_ttl,
    )
}

fn render_manifest(plan: &ResolvedDnsPlan) -> String {
    let mut out = format!(
        "location={}\nprovider={}\nservice={}\ncontainer_ipv4={}\ningress_ipv4={}\n",
        plan.location, plan.provider, plan.service, plan.container_ipv4, plan.ingress_ipv4,
    );

    for warning in &plan.warnings {
        out.push_str(&format!("warning={warning}\n"));
    }

    out
}

fn zone_filename(zone: &str) -> String {
    format!("db.{}", zone.trim_end_matches('.'))
}

fn zone_fqdn(zone: &str) -> String {
    if zone.ends_with('.') {
        zone.to_owned()
    } else {
        format!("{zone}.")
    }
}

fn write(path: &Path, contents: &str) -> Result<()> {
    if contents.contains('\0') {
        bail!("refusing to write NUL byte to {}", path.display());
    }

    fs::write(path, contents).with_context(|| format!("failed to write {}", path.display()))
}