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};
use serde_json::json;

use crate::paths::NetweftPaths;
use crate::plan::docker::ResolvedDockerPlan;

pub fn render_docker(plan: &ResolvedDockerPlan, paths: &NetweftPaths) -> Result<PathBuf> {
    let output = paths
        .generated_dir
        .join(&plan.location)
        .join("hosts")
        .join(&plan.host)
        .join("docker");
    fs::create_dir_all(&output)?;

    write(&output.join("daemon.desired.json"), &daemon_json(plan)?)?;
    write(&output.join("action-plan.txt"), &action_plan(plan))?;
    write(&output.join("apply.sh"), &apply_script(plan))?;
    write(&output.join("verify.sh"), &verify_script(plan))?;
    write(&output.join("rollback.sh"), rollback_script())?;

    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        for name in ["apply.sh", "verify.sh", "rollback.sh"] {
            fs::set_permissions(output.join(name), fs::Permissions::from_mode(0o755))?;
        }
    }

    Ok(output)
}

fn daemon_json(plan: &ResolvedDockerPlan) -> Result<String> {
    let value = json!({
        "bip": format!("{}/{}", plan.daemon.bridge_ipv4_gateway, plan.daemon.bridge_ipv4_cidr.prefix_len()),
        "ipv6": true,
        "fixed-cidr-v6": plan.daemon.bridge_ipv6_cidr.to_string(),
        "ip6tables": true,
        "default-address-pools": [
            {"base": plan.daemon.ipv4_pool_base.to_string(), "size": plan.daemon.ipv4_pool_size},
            {"base": plan.daemon.ipv6_pool_base.to_string(), "size": plan.daemon.ipv6_pool_size}
        ]
    });
    Ok(format!("{}\n", serde_json::to_string_pretty(&value)?))
}

fn action_plan(plan: &ResolvedDockerPlan) -> String {
    let mut output = format!(
        "Generated by Netweft. Review before applying.\n\nHost: {}\nLocation: {}\n\n",
        plan.host, plan.location
    );
    output.push_str(&format!(
        "docker0 {} | {}\n",
        plan.daemon.bridge_ipv4_cidr, plan.daemon.bridge_ipv6_cidr
    ));
    for network in &plan.networks {
        output.push_str(&format!(
            "{} ({}) {} | {}{}\n",
            network.logical_name,
            network.docker_name,
            network.ipv4_cidr,
            network
                .ipv6_cidr
                .map(|value| value.to_string())
                .unwrap_or_default(),
            network
                .previous_ipv6_cidr
                .map(|value| format!(" migrate-from={value}"))
                .unwrap_or_else(|| " adopt-existing".to_owned())
        ));
    }
    output
}

fn apply_script(plan: &ResolvedDockerPlan) -> String {
    let mut output = format!(
        r#"#!/usr/bin/env bash
set -euo pipefail

[ "$(id -u)" -eq 0 ] || {{ echo "run as root" >&2; exit 1; }}
script_dir=$(cd -- "$(dirname -- "${{BASH_SOURCE[0]}}")" && pwd)
backup="/root/netweft-backups/docker-{host}-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$backup"

if [ -f /etc/docker/daemon.json ]; then
  cp -a /etc/docker/daemon.json "$backup/daemon.json"
else
  : > "$backup/daemon.json.absent"
fi

current=$(mktemp)
[ -f /etc/docker/daemon.json ] && cp /etc/docker/daemon.json "$current" || printf '{{}}\n' > "$current"
jq -s '.[0] * .[1]' "$current" "$script_dir/daemon.desired.json" > "$backup/daemon.json.merged"
dockerd --validate --config-file "$backup/daemon.json.merged"
install -m 0644 "$backup/daemon.json.merged" /etc/docker/daemon.json
rm -f "$current"

# Record the containers that were running before restarting Docker.
docker ps --format '{{{{.Names}}}}' > "$backup/running-containers.txt"

systemctl restart docker
docker info >/dev/null
"#,
        host = plan.host
    );

    for network in &plan.networks {
        if let Some(previous) = network.previous_ipv6_cidr {
            let ipv6 = network.ipv6_cidr.expect("migration requires IPv6");
            let ipv6_gateway = network.ipv6_gateway.expect("migration requires IPv6");
            output.push_str(&format!(
                r#"
# Discover Compose projects from Docker labels, stop them, patch only the old prefix,
# recreate the external network, then start the same projects again.
projects="$backup/{plain}.projects.tsv"
ids=$(docker ps -aq --filter network={name})
if [ -n "$ids" ]; then
  docker inspect $ids | jq -r '.[] | [
    .Config.Labels["com.docker.compose.project"],
    .Config.Labels["com.docker.compose.project.working_dir"],
    .Config.Labels["com.docker.compose.project.config_files"]
  ] | select(.[0] != null and .[1] != null and .[2] != null) | @tsv' | sort -u > "$projects"
else
  : > "$projects"
fi

while IFS=$'\t' read -r project working_dir config_files; do
  [ -n "$project" ] || continue
  (
    cd "$working_dir"
    args=()
    IFS=, read -ra files <<< "$config_files"
    for file in "${{files[@]}}"; do args+=(-f "$file"); done
    docker compose "${{args[@]}}" -p "$project" down
    python3 - {old} {new} "$backup" "$working_dir" "${{files[@]}}" <<'PY'
from pathlib import Path
import shutil, sys
old, new, backup, working_dir, *files = sys.argv[1:]
working = Path(working_dir)
for value in files + [".env"]:
    path = Path(value)
    if not path.is_absolute():
        path = working / path
    if not path.is_file():
        continue
    text = path.read_text()
    if old not in text:
        continue
    saved = Path(backup) / "compose-files" / Path(str(path).lstrip("/"))
    saved.parent.mkdir(parents=True, exist_ok=True)
    shutil.copy2(path, saved)
    path.write_text(text.replace(old, new))
    print(f"updated {{path}}")
PY
  )
done < "$projects"

if docker network inspect {name} >/dev/null 2>&1; then
  attached=$(docker network inspect {name} --format '{{{{len .Containers}}}}')
  [ "$attached" -eq 0 ] || {{ echo "{plain} still has attached containers" >&2; exit 1; }}
  docker network rm {name}
fi

docker network create --driver bridge --ipv6 \
  --subnet {ipv4} --gateway {ipv4_gateway} \
  --subnet {ipv6} --gateway {ipv6_gateway} \
  {name}

while IFS=$'\t' read -r project working_dir config_files; do
  [ -n "$project" ] || continue
  (
    cd "$working_dir"
    args=()
    IFS=, read -ra files <<< "$config_files"
    for file in "${{files[@]}}"; do args+=(-f "$file"); done
    docker compose "${{args[@]}}" -p "$project" up -d
  )
done < "$projects"
"#,
                name = shell(&network.docker_name),
                plain = network.docker_name,
                old = shell(&prefix(previous)),
                new = shell(&prefix(ipv6)),
                ipv4 = shell(&network.ipv4_cidr.to_string()),
                ipv4_gateway = shell(&network.ipv4_gateway.to_string()),
                ipv6 = shell(&ipv6.to_string()),
                ipv6_gateway = shell(&ipv6_gateway.to_string()),
            ));
        } else {
            output.push_str(&format!(
                "docker network inspect {} >/dev/null\n",
                shell(&network.docker_name)
            ));
        }
    }

    output.push_str(
        r#"if [ -f "$backup/running-containers.txt" ]; then
  while IFS= read -r container; do
    [ -n "$container" ] || continue

    if docker inspect "$container" >/dev/null 2>&1 \
      && [ "$(docker inspect "$container" --format '{{.State.Running}}')" != "true" ]; then
      echo "Restoring previously running container: $container"
      docker start "$container"
    fi
  done < "$backup/running-containers.txt"
fi

echo "Applied Netweft Docker plan. Backup: $backup"
"#,
    );
    output
}

fn verify_script(plan: &ResolvedDockerPlan) -> String {
    let mut output = String::from(
        "#!/usr/bin/env bash\nset -euo pipefail\n\ncat /etc/docker/daemon.json\ndocker network inspect bridge\n",
    );
    for network in &plan.networks {
        output.push_str(&format!(
            "docker network inspect {}\n",
            shell(&network.docker_name)
        ));
    }
    output.push_str("ip -br address show docker0 || true\nip -6 route | grep -E '2603:8001:a000:|fdd7:d134:61e3:' || true\n");
    output
}

fn rollback_script() -> &'static str {
    r#"#!/usr/bin/env bash
set -euo pipefail

[ "$(id -u)" -eq 0 ] || { echo "run as root" >&2; exit 1; }
backup=${1:?usage: rollback.sh /root/netweft-backups/docker-HOST-TIMESTAMP}

if [ -f "$backup/daemon.json" ]; then
  install -m 0644 "$backup/daemon.json" /etc/docker/daemon.json
elif [ -f "$backup/daemon.json.absent" ]; then
  rm -f /etc/docker/daemon.json
else
  echo "missing daemon backup" >&2
  exit 1
fi

if [ -d "$backup/compose-files" ]; then
  while IFS= read -r saved; do
    target="/${saved#"$backup/compose-files/"}"
    install -D -m 0644 "$saved" "$target"
  done < <(find "$backup/compose-files" -type f -print)
fi

systemctl restart docker
echo "Restored daemon and Compose files. Recreate migrated named networks before restarting projects."
"#
}

fn prefix(network: ipnet::Ipv6Net) -> String {
    network
        .network()
        .to_string()
        .trim_end_matches("::")
        .to_owned()
        + "::"
}

fn shell(value: &str) -> String {
    format!("'{}'", value.replace('\'', "'\\''"))
}

fn write(path: &Path, contents: &str) -> Result<()> {
    fs::write(path, contents).with_context(|| format!("failed to write {}", path.display()))
}