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