use crate::config::{Profile, Route};
use anyhow::{Result, bail};
use std::path::{Path, PathBuf};
pub fn netplan_path(profile_name: &str) -> Result<PathBuf> {
let safe = !profile_name.is_empty()
&& profile_name
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '_' | '-'));
if !safe {
bail!(
"profile name '{profile_name}' is not a safe netplan filename component \
(only letters, digits, '.', '_', '-' are allowed)"
);
}
Ok(PathBuf::from(format!(
"/etc/netplan/90-vlanctl-{profile_name}.yaml"
)))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Renderer {
Networkd,
NetworkManager,
}
pub fn renderer_for(device: &str) -> Renderer {
renderer_for_in(
device,
Path::new("/sys/class/net"),
Path::new("/run/NetworkManager/devices"),
)
}
fn renderer_for_in(device: &str, sys_class_net: &Path, nm_devices: &Path) -> Renderer {
let Ok(ifindex) = std::fs::read_to_string(sys_class_net.join(device).join("ifindex")) else {
return Renderer::Networkd;
};
if nm_devices.join(ifindex.trim()).exists() {
Renderer::NetworkManager
} else {
Renderer::Networkd
}
}
pub fn render_netplan(profile: &Profile, device: &str, renderer: Renderer) -> String {
let mut out = format!(
"# Written by vlanctl for profile '{}'. Safe to delete.\n",
first_line(&profile.name)
);
let mac_routes: Vec<&Route> = profile
.interfaces
.iter()
.flat_map(|i| i.routes.iter())
.filter(|r| r.mac.is_some())
.collect();
if !mac_routes.is_empty() {
out.push_str(
"# NOTE: netplan has no static-ARP-entry key, so the route(s) below\n\
# will exist after reboot but will not resolve until Apply runs again:\n",
);
for route in &mac_routes {
out.push_str(&format!(
"# {} (mac {})\n",
first_line(&route.destination),
first_line(route.mac.as_deref().expect("filtered to Some"))
));
}
}
out.push_str("network:\n version: 2\n");
let untagged: Vec<_> = profile
.interfaces
.iter()
.filter(|i| i.vlan.is_none())
.collect();
out.push_str(" ethernets:\n");
out.push_str(&format!(" {device}:\n"));
push_nm_renderer(&mut out, renderer, 6);
if untagged.is_empty() {
out.push_str(" dhcp4: false\n link-local: []\n");
push_nm_parent_passthrough(&mut out, renderer);
} else {
out.push_str(" addresses:\n");
for i in &untagged {
out.push_str(&format!(" - {}\n", i.address));
}
if let Some(mtu) = untagged.iter().find_map(|i| i.mtu) {
out.push_str(&format!(" mtu: {mtu}\n"));
}
push_routes(&mut out, untagged.iter().flat_map(|i| i.routes.iter()), 6);
}
let tagged: Vec<_> = profile
.interfaces
.iter()
.filter(|i| i.vlan.is_some())
.collect();
if !tagged.is_empty() {
out.push_str(" vlans:\n");
for i in &tagged {
let id = i.vlan.expect("filtered to Some");
out.push_str(&format!(" {device}.{id}:\n"));
push_nm_renderer(&mut out, renderer, 6);
out.push_str(&format!(" id: {id}\n"));
out.push_str(&format!(" link: {device}\n"));
out.push_str(" addresses:\n");
out.push_str(&format!(" - {}\n", i.address));
if let Some(mtu) = i.mtu {
out.push_str(&format!(" mtu: {mtu}\n"));
}
push_routes(&mut out, i.routes.iter(), 6);
}
}
out
}
fn first_line(s: &str) -> &str {
s.lines().next().unwrap_or("")
}
fn push_nm_renderer(out: &mut String, renderer: Renderer, indent: usize) {
if renderer == Renderer::NetworkManager {
out.push_str(&format!(
"{:indent$}renderer: NetworkManager\n",
"",
indent = indent
));
}
}
fn push_nm_parent_passthrough(out: &mut String, renderer: Renderer) {
if renderer != Renderer::NetworkManager {
return;
}
out.push_str(
" networkmanager:\n\
\x20 passthrough:\n\
\x20 connection.autoconnect-priority: \"999\"\n\
\x20 ipv4.method: \"disabled\"\n",
);
}
fn push_routes<'a>(out: &mut String, routes: impl Iterator<Item = &'a Route>, indent: usize) {
let pad = " ".repeat(indent);
let mut any = false;
for route in routes {
if !any {
out.push_str(&format!("{pad}routes:\n"));
any = true;
}
out.push_str(&format!("{pad} - to: {}\n", route.destination));
match &route.gateway {
Some(gw) => out.push_str(&format!("{pad} via: {gw}\n")),
None => out.push_str(&format!("{pad} scope: link\n")),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::{Interface, Profile, Route};
fn iris_profile() -> Profile {
Profile {
name: "derived-iris".to_string(),
description: None,
device: Some("eth0".to_string()),
interfaces: vec![Interface {
vlan: Some(10),
address: "192.168.10.90/24".parse().expect("valid CIDR"),
mtu: None,
routes: vec![Route {
destination: "192.168.10.150/32".to_string(),
gateway: None,
mac: None,
}],
}],
}
}
fn halo_profile() -> Profile {
Profile {
name: "derived-halo".to_string(),
description: None,
device: Some("eth0".to_string()),
interfaces: vec![Interface {
vlan: None,
address: "192.168.1.100/24".parse().expect("valid CIDR"),
mtu: None,
routes: Vec::new(),
}],
}
}
#[test]
fn path_is_namespaced_and_ordered_after_the_distro_defaults() {
let p = netplan_path("derived-iris").expect("a safe name");
assert_eq!(
p,
PathBuf::from("/etc/netplan/90-vlanctl-derived-iris.yaml")
);
}
#[test]
fn path_rejects_a_name_outside_the_safe_character_set() {
for bad in ["../evil", "a/b", "", "with space", "semi;colon"] {
assert!(
netplan_path(bad).is_err(),
"{bad:?} should not produce a path"
);
}
}
#[test]
fn renders_a_tagged_interface_with_its_host_route() {
let yaml = render_netplan(&iris_profile(), "eth0", Renderer::Networkd);
let expected = "\
# Written by vlanctl for profile 'derived-iris'. Safe to delete.
network:
version: 2
ethernets:
eth0:
dhcp4: false
link-local: []
vlans:
eth0.10:
id: 10
link: eth0
addresses:
- 192.168.10.90/24
routes:
- to: 192.168.10.150/32
scope: link
";
assert_eq!(yaml, expected);
}
#[test]
fn renders_an_untagged_entry_under_ethernets() {
let yaml = render_netplan(&halo_profile(), "eth0", Renderer::Networkd);
assert!(yaml.contains("ethernets:"), "got {yaml}");
assert!(yaml.contains("eth0:"), "got {yaml}");
assert!(!yaml.contains("vlans:"), "got {yaml}");
assert!(!yaml.contains("dhcp4: false"), "got {yaml}");
}
#[test]
fn stubs_the_parent_device_when_no_untagged_interface_exists() {
let yaml = render_netplan(&iris_profile(), "eth0", Renderer::Networkd);
assert!(
yaml.contains(" ethernets:\n eth0:\n dhcp4: false\n"),
"got {yaml}"
);
}
#[test]
fn stubbed_parent_does_not_take_a_link_local_address() {
let yaml = render_netplan(&iris_profile(), "eth0", Renderer::Networkd);
assert!(
yaml.contains(" ethernets:\n eth0:\n dhcp4: false\n link-local: []\n"),
"got {yaml}"
);
}
#[test]
fn renders_mtu_when_the_interface_sets_it() {
let mut profile = iris_profile();
profile.interfaces[0].mtu = Some(1500);
let yaml = render_netplan(&profile, "eth0", Renderer::Networkd);
assert!(yaml.contains(" mtu: 1500\n"), "got {yaml}");
}
#[test]
fn renders_mtu_on_an_untagged_interface() {
let mut profile = halo_profile();
profile.interfaces[0].mtu = Some(9000);
let yaml = render_netplan(&profile, "eth0", Renderer::Networkd);
assert!(yaml.contains(" mtu: 9000\n"), "got {yaml}");
}
#[test]
fn warns_in_the_header_when_a_route_carries_a_static_arp_entry() {
let mut profile = halo_profile();
profile.interfaces[0].routes.push(Route {
destination: "192.168.10.151/32".to_string(),
gateway: None,
mac: Some("00:00:5e:00:53:01".to_string()),
});
let yaml = render_netplan(&profile, "eth0", Renderer::Networkd);
assert!(yaml.starts_with("# Written by vlanctl"), "got {yaml}");
assert!(yaml.contains("NOTE"), "got {yaml}");
assert!(yaml.contains("192.168.10.151/32"), "got {yaml}");
assert!(yaml.contains("00:00:5e:00:53:01"), "got {yaml}");
assert!(yaml.contains("- to: 192.168.10.151/32"), "got {yaml}");
}
fn netplan_binary() -> Option<&'static str> {
if std::path::Path::new("/usr/sbin/netplan").is_file() {
return Some("/usr/sbin/netplan");
}
std::process::Command::new("netplan")
.arg("info")
.output()
.ok()
.map(|_| "netplan")
}
fn require_netplan(label: &str) -> Option<&'static str> {
match netplan_binary() {
Some(bin) => Some(bin),
None if cfg!(target_os = "linux") => panic!(
"`netplan` not found (checked /usr/sbin/netplan and PATH) — \
refusing to silently skip {label}; install netplan.io or \
fix PATH rather than let this test go green with no coverage"
),
None => {
eprintln!("skipping {label}: not on Linux and `netplan` not found");
None
}
}
}
fn netplan_generate(bin: &str, root: &Path) -> std::process::Output {
std::process::Command::new(bin)
.arg("generate")
.arg("--root-dir")
.arg(root)
.output()
.expect("run `netplan generate`")
}
fn write_fixture(dir: &Path, name: &str, contents: &str) {
let file = dir.join(name);
std::fs::write(&file, contents).expect("write fixture");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&file, std::fs::Permissions::from_mode(0o600))
.expect("chmod 600 the staged file");
}
}
fn assert_netplan_generate_accepts(yaml: &str, label: &str) {
let Some(bin) = require_netplan(label) else {
return;
};
let root = std::env::temp_dir().join(format!(
"vlanctl-netplan-generate-test-{label}-{}",
std::process::id()
));
let netplan_dir = root.join("etc/netplan");
std::fs::create_dir_all(&netplan_dir).expect("create temp netplan root");
write_fixture(&netplan_dir, "90-vlanctl-test.yaml", yaml);
let out = netplan_generate(bin, &root);
let stderr = String::from_utf8_lossy(&out.stderr).to_string();
let _ = std::fs::remove_dir_all(&root);
assert!(
out.status.success(),
"netplan generate exited {:?} for {label}: {stderr}",
out.status.code()
);
assert!(
!stderr.contains("Error in network definition"),
"netplan rejected the {label} rendering: {stderr}"
);
assert!(
!stderr.contains("assertion failed") && !stderr.contains("ERROR:"),
"netplan's backend crashed on the {label} rendering: {stderr}"
);
}
#[cfg_attr(not(feature = "netplan-tests"), ignore)]
#[test]
fn netplan_generate_accepts_the_tagged_rendering() {
assert_netplan_generate_accepts(
&render_netplan(&iris_profile(), "eth0", Renderer::Networkd),
"tagged",
);
}
struct ScratchDir(std::path::PathBuf);
impl ScratchDir {
fn new(label: &str) -> Self {
let dir = std::env::temp_dir()
.join(format!("vlanctl-renderer-{label}-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).expect("mkdir scratch dir");
ScratchDir(dir)
}
fn path(&self) -> &Path {
&self.0
}
}
impl Drop for ScratchDir {
fn drop(&mut self) {
let _ = std::fs::remove_dir_all(&self.0);
}
}
#[test]
fn a_device_network_manager_has_claimed_renders_as_network_manager() {
let root = ScratchDir::new("claimed");
let sys = root.path().join("sys");
let nm = root.path().join("nm");
std::fs::create_dir_all(sys.join("eth0")).expect("mkdir");
std::fs::write(sys.join("eth0").join("ifindex"), "324\n").expect("write");
std::fs::create_dir_all(&nm).expect("mkdir");
std::fs::write(nm.join("324"), "").expect("write");
assert_eq!(renderer_for_in("eth0", &sys, &nm), Renderer::NetworkManager);
}
#[test]
fn a_device_network_manager_has_not_claimed_renders_as_networkd() {
let root = ScratchDir::new("unclaimed");
let sys = root.path().join("sys");
let nm = root.path().join("nm");
std::fs::create_dir_all(sys.join("eth0")).expect("mkdir");
std::fs::write(sys.join("eth0").join("ifindex"), "324\n").expect("write");
std::fs::create_dir_all(&nm).expect("mkdir");
std::fs::write(nm.join("2"), "").expect("write");
assert_eq!(renderer_for_in("eth0", &sys, &nm), Renderer::Networkd);
}
#[test]
fn an_unknown_device_falls_back_to_networkd() {
let root = ScratchDir::new("unknown");
assert_eq!(
renderer_for_in("nope0", &root.path().join("sys"), &root.path().join("nm")),
Renderer::Networkd
);
}
#[test]
fn the_network_manager_rendering_pins_every_netdef_it_owns() {
let yaml = render_netplan(&iris_two_vlan_profile(), "eth0", Renderer::NetworkManager);
assert_eq!(
yaml.matches("renderer: NetworkManager").count(),
3,
"parent + both VLANs, got {yaml}"
);
assert!(
!yaml.contains("\n renderer:"),
"never the top-level renderer — that re-renders the whole host: {yaml}"
);
}
#[test]
fn the_network_manager_parent_disables_ipv4_and_outranks_autoconnect() {
let yaml = render_netplan(&iris_two_vlan_profile(), "eth0", Renderer::NetworkManager);
assert!(
yaml.contains("connection.autoconnect-priority: \"999\""),
"got {yaml}"
);
assert!(yaml.contains("ipv4.method: \"disabled\""), "got {yaml}");
}
#[test]
fn the_networkd_rendering_carries_no_network_manager_keys() {
let yaml = render_netplan(&iris_two_vlan_profile(), "eth0", Renderer::Networkd);
assert!(!yaml.contains("renderer:"), "got {yaml}");
assert!(!yaml.contains("networkmanager:"), "got {yaml}");
assert!(
yaml.contains(" dhcp4: false\n link-local: []\n"),
"got {yaml}"
);
}
fn iris_two_vlan_profile() -> Profile {
let mut p = iris_profile();
p.interfaces.push(Interface {
vlan: Some(11),
address: "192.168.11.87/24".parse().expect("valid CIDR"),
mtu: None,
routes: vec![Route {
destination: "192.168.11.102/32".to_string(),
gateway: None,
mac: None,
}],
});
p
}
#[cfg_attr(not(feature = "netplan-tests"), ignore)]
#[test]
fn network_manager_keyfiles_disable_the_parent_and_outrank_autoconnect() {
let Some(bin) = require_netplan("nm-passthrough") else {
return;
};
let root =
std::env::temp_dir().join(format!("vlanctl-netplan-nm-pass-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
let netplan_dir = root.join("etc/netplan");
std::fs::create_dir_all(&netplan_dir).expect("create temp netplan root");
write_fixture(
&netplan_dir,
"90-vlanctl-test.yaml",
&render_netplan(&iris_two_vlan_profile(), "eth0", Renderer::NetworkManager),
);
let out = netplan_generate(bin, &root);
let stderr = String::from_utf8_lossy(&out.stderr).to_string();
let nm_dir = root.join("run/NetworkManager/system-connections");
let names: Vec<String> = std::fs::read_dir(&nm_dir)
.map(|e| {
e.flatten()
.map(|f| f.file_name().to_string_lossy().into_owned())
.collect()
})
.unwrap_or_default();
let parent =
std::fs::read_to_string(nm_dir.join("netplan-eth0.nmconnection")).unwrap_or_default();
let networkd: Vec<String> = std::fs::read_dir(root.join("run/systemd/network"))
.map(|e| {
e.flatten()
.map(|f| f.file_name().to_string_lossy().into_owned())
.collect()
})
.unwrap_or_default();
let _ = std::fs::remove_dir_all(&root);
assert!(
!stderr.contains("Error in network definition")
&& !stderr.contains("assertion failed")
&& !stderr.contains("ERROR:"),
"netplan did not accept the NM rendering: {stderr}"
);
assert_eq!(names.len(), 3, "parent + both VLANs, got {names:?}");
assert!(
networkd.is_empty(),
"a networkd unit means the backends split: {networkd:?}"
);
assert!(
parent.contains("autoconnect-priority=999"),
"parent must outrank NM's stock wired profile: {parent}"
);
assert!(
parent.contains("method=disabled"),
"parent must take no address at all: {parent}"
);
}
#[cfg_attr(not(feature = "netplan-tests"), ignore)]
#[test]
fn netplan_generate_accepts_a_two_vlan_rendering() {
assert_netplan_generate_accepts(
&render_netplan(&iris_two_vlan_profile(), "eth0", Renderer::Networkd),
"two-vlan",
);
}
#[cfg_attr(not(feature = "netplan-tests"), ignore)]
#[test]
fn netplan_generate_accepts_the_untagged_rendering() {
assert_netplan_generate_accepts(
&render_netplan(&halo_profile(), "eth0", Renderer::Networkd),
"untagged",
);
}
#[cfg_attr(not(feature = "netplan-tests"), ignore)]
#[test]
fn netplan_generate_does_not_move_another_netdefs_backend() {
let Some(bin) = require_netplan("hijack regression") else {
return;
};
let root = std::env::temp_dir().join(format!(
"vlanctl-netplan-hijack-test-{}",
std::process::id()
));
let netplan_dir = root.join("etc/netplan");
std::fs::create_dir_all(&netplan_dir).expect("create temp netplan root");
write_fixture(
&netplan_dir,
"00-installer-config.yaml",
"network:\n version: 2\n renderer: networkd\n ethernets:\n ens3:\n dhcp4: true\n",
);
write_fixture(
&netplan_dir,
"90-vlanctl-derived-iris.yaml",
&render_netplan(&iris_profile(), "eth0", Renderer::Networkd),
);
let out = netplan_generate(bin, &root);
let stderr = String::from_utf8_lossy(&out.stderr).to_string();
let ens3_kept_its_networkd_unit = std::fs::read_dir(root.join("run/systemd/network"))
.map(|entries| {
entries
.filter_map(Result::ok)
.any(|e| e.file_name().to_string_lossy().contains("ens3"))
})
.unwrap_or(false);
let _ = std::fs::remove_dir_all(&root);
assert!(
out.status.success(),
"netplan generate exited {:?}: {stderr}",
out.status.code()
);
assert!(
!stderr.contains("Error in network definition"),
"netplan rejected the fixture: {stderr}"
);
assert!(
ens3_kept_its_networkd_unit,
"installing our permanence file moved 'ens3' off systemd-networkd — \
our rendering is leaking a renderer choice beyond its own netdefs"
);
}
}