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::host_network::{
    ResolvedHostBridge, ResolvedHostIpv6Mode, ResolvedHostNetworkPlan,
};

pub fn render_proxmox(plan: &ResolvedHostNetworkPlan, output: &Path) -> Result<PathBuf> {
    let parent = output
        .parent()
        .context("Proxmox output directory has no parent")?;

    fs::create_dir_all(parent)?;

    let temp = parent.join(format!(".proxmox-{}.tmp", std::process::id()));

    if temp.exists() {
        fs::remove_dir_all(&temp)?;
    }

    fs::create_dir_all(temp.join("etc/network"))?;

    write(
        &temp.join("etc/network/interfaces"),
        &render_interfaces(plan)?,
    )?;

    write(&temp.join("etc/hosts"), &render_hosts(plan))?;

    write(&temp.join("etc/resolv.conf"), &render_resolv_conf(plan))?;

    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 Proxmox tree from {} to {}",
            temp.display(),
            output.display()
        )
    })?;

    Ok(output.to_path_buf())
}

fn render_interfaces(plan: &ResolvedHostNetworkPlan) -> Result<String> {
    let mut out = String::new();

    out.push_str("# Generated by Netweft. Do not edit.\n");
    out.push_str(&format!("# Host: {}\n", plan.host));
    out.push_str(&format!("# Location: {}\n", plan.location));
    out.push_str("# Adapter: proxmox\n\n");

    out.push_str("auto lo\n");
    out.push_str("iface lo inet loopback\n\n");

    for link in &plan.links {
        out.push_str(&format!("iface {} inet manual\n", link.name));
    }

    if !plan.links.is_empty() {
        out.push('\n');
    }

    for (index, bridge) in plan.bridges.iter().enumerate() {
        render_bridge(&mut out, bridge)?;

        if index + 1 < plan.bridges.len() {
            out.push('\n');
        }
    }

    if plan.preserve_includes {
        out.push('\n');
        out.push_str("source /etc/network/interfaces.d/*\n");
    }

    Ok(out)
}

fn render_bridge(out: &mut String, bridge: &ResolvedHostBridge) -> Result<()> {
    out.push_str(&format!("auto {}\n", bridge.name));

    match bridge.ipv4 {
        Some(address) => {
            out.push_str(&format!("iface {} inet static\n", bridge.name));
            out.push_str(&format!("        address {address}\n"));

            if let Some(gateway) = bridge.ipv4_gateway {
                out.push_str(&format!("        gateway {gateway}\n"));
            }
        }
        None => {
            out.push_str(&format!("iface {} inet manual\n", bridge.name));
        }
    }

    let ports = if bridge.ports.is_empty() {
        "none".to_owned()
    } else {
        bridge.ports.join(" ")
    };

    out.push_str(&format!("        bridge-ports {ports}\n"));
    out.push_str(&format!("        bridge-stp {}\n", on_off(bridge.stp)));
    out.push_str(&format!("        bridge-fd {}\n", bridge.forward_delay));

    if bridge.vlan_aware {
        out.push_str("        bridge-vlan-aware yes\n");

        if let Some(vlans) = &bridge.allowed_vlans {
            out.push_str(&format!("        bridge-vids {vlans}\n"));
        }
    }

    if let Some(comment) = &bridge.comment {
        out.push_str(&format!("# {comment}\n"));
    }

    match bridge.ipv6_mode {
        ResolvedHostIpv6Mode::Disabled => {}
        ResolvedHostIpv6Mode::Slaac => {
            out.push('\n');
            out.push_str(&format!("iface {} inet6 auto\n", bridge.name));
        }
        ResolvedHostIpv6Mode::Static => {
            bail!(
                "Proxmox rendering for bridge '{}' does not yet support static IPv6",
                bridge.name
            );
        }
    }

    Ok(())
}

fn render_hosts(plan: &ResolvedHostNetworkPlan) -> String {
    let management = plan.bridges.iter().find(|bridge| {
        bridge.location_interface.as_deref() == Some(plan.management_interface.as_str())
    });

    let mut out = String::new();

    out.push_str("# Generated by Netweft. Do not edit.\n");
    out.push_str("127.0.0.1 localhost.localdomain localhost\n");

    if let Some(address) = management.and_then(|bridge| bridge.ipv4) {
        out.push_str(&format!("{} {} {}\n", address.addr(), plan.fqdn, plan.host));
    }

    out.push('\n');
    out.push_str("::1     ip6-localhost ip6-loopback\n");
    out.push_str("fe00::0 ip6-localnet\n");
    out.push_str("ff00::0 ip6-mcastprefix\n");
    out.push_str("ff02::1 ip6-allnodes\n");
    out.push_str("ff02::2 ip6-allrouters\n");
    out.push_str("ff02::3 ip6-allhosts\n");

    out
}

fn render_resolv_conf(plan: &ResolvedHostNetworkPlan) -> String {
    let mut out = String::new();

    out.push_str("# Generated by Netweft. Do not edit.\n");

    if !plan.search_domains.is_empty() {
        out.push_str(&format!("search {}\n", plan.search_domains.join(" ")));
    }

    for server in &plan.dns_servers {
        out.push_str(&format!("nameserver {server}\n"));
    }

    out
}

fn render_manifest(plan: &ResolvedHostNetworkPlan) -> String {
    let mut out = String::new();

    out.push_str("adapter=proxmox\n");
    out.push_str(&format!("host={}\n", plan.host));
    out.push_str(&format!("location={}\n", plan.location));
    out.push_str("provider=proxmox-ifupdown2\n");

    for bridge in &plan.bridges {
        let ipv4 = bridge
            .ipv4
            .map(|value| value.to_string())
            .unwrap_or_else(|| "none".to_owned());

        out.push_str(&format!(
            "bridge={} ports={} ipv4={} ipv6={} vlan_aware={}\n",
            bridge.name,
            if bridge.ports.is_empty() {
                "none".to_owned()
            } else {
                bridge.ports.join(",")
            },
            ipv4,
            bridge.ipv6_mode.as_str(),
            bridge.vlan_aware,
        ));
    }

    out.push_str("owns=etc/network/interfaces,etc/hosts,etc/resolv.conf\n");
    out.push_str("preserves=etc/network/interfaces.d/*\n");
    out.push_str("excludes=etc/network/interfaces.d/sdn,etc/pve/corosync.conf\n");

    out
}

fn on_off(value: bool) -> &'static str {
    if value { "on" } else { "off" }
}

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()))
}