use crate::config::Profile;
use crate::device::resolve_device;
use crate::net::{Cmd, CommandRunner};
use crate::plan::{Platform, bringup_commands_for};
use crate::state::{ParentConfig, State};
use anyhow::{Context, Result, bail};
use ipnet::IpNet;
use std::path::Path;
pub(crate) fn live_interfaces<R: CommandRunner + ?Sized>(runner: &mut R) -> Result<Vec<String>> {
let out = runner.run(&Cmd::new("ifconfig", &["-l"]))?;
Ok(out.split_whitespace().map(|s| s.to_string()).collect())
}
pub(crate) fn device_inet_addresses<R: CommandRunner + ?Sized>(
runner: &mut R,
device: &str,
) -> Result<Vec<IpNet>> {
let out = runner.run(&Cmd::new("ifconfig", &[device]))?;
Ok(out
.lines()
.filter_map(|line| {
let mut toks = line.split_whitespace();
if toks.next() != Some("inet") {
return None;
}
let addr = toks.next()?;
let prefix = match toks.next() {
Some("netmask") => toks.next().and_then(prefix_from_hex_netmask).unwrap_or(32),
_ => 32,
};
format!("{addr}/{prefix}").parse::<IpNet>().ok()
})
.collect())
}
fn prefix_from_hex_netmask(hex: &str) -> Option<u8> {
let hex = hex.strip_prefix("0x")?;
let mask = u32::from_str_radix(hex, 16).ok()?;
let prefix = mask.count_ones() as u8;
let contiguous = if prefix == 0 {
0
} else {
u32::MAX << (32 - u32::from(prefix))
};
(mask == contiguous).then_some(prefix)
}
pub fn apply<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
profile: &Profile,
device_override: Option<&str>,
state_path: &Path,
dry_run: bool,
) -> Result<Vec<String>> {
platform.validate_profile(profile)?;
let mut state = State::load(state_path)?;
if state.active_profile.is_some() {
let previous = state
.backend
.as_deref()
.and_then(crate::plan::platform_named);
let teardown_platform: &dyn Platform = previous.as_deref().unwrap_or(platform);
down(runner, teardown_platform, state_path, dry_run)?;
}
let device = resolve_device(
platform,
runner,
device_override.or(profile.device.as_deref()),
)?;
let interfaces: Vec<String> = profile
.interfaces
.iter()
.map(|i| platform.iface_name(i, &device))
.filter(|name| *name != device)
.collect();
let existing = platform.list_devices(runner)?;
for iface in &interfaces {
if existing.contains(iface) {
bail!(
"interface {iface} already exists and was not created by vlanctl; \
refusing to touch it (destroy it manually if it is stale)"
);
}
}
let taken = platform.existing_vlans(runner, &device)?;
for interface in profile.interfaces.iter().filter(|i| i.vlan.is_some()) {
let Some(id) = interface.vlan else { continue };
if let Some((_, holder)) = taken.iter().find(|(taken_id, _)| *taken_id == id) {
bail!(
"vlan id {id} is already in use on {device} by interface {holder}, \
which vlanctl did not create; refusing to touch it (the kernel \
allows one VLAN per id per parent, whatever it is named)"
);
}
}
let parent = platform.parent_snapshot(runner, &device)?;
let mut created: Vec<String> = Vec::new();
for interface in &profile.interfaces {
let iface = platform.iface_name(interface, &device);
if interface.vlan.is_none() {
let already_configured = platform
.addresses_on(runner, &iface)?
.iter()
.any(|net| net.addr() == interface.address.addr());
if already_configured {
continue;
}
}
for cmd in bringup_commands_for(platform, interface, &device) {
let is_create = platform.records_created_interface(&cmd);
match runner.run(&cmd) {
Ok(_) => {
if is_create {
created.push(iface.clone());
}
}
Err(e) => {
rollback(runner, platform, &created, parent.as_ref());
return Err(e).with_context(|| {
format!("applying profile '{}'; rolled back", profile.name)
});
}
}
}
}
state.active_profile = Some(profile.name.clone());
state.interfaces = created.clone();
state.backend = Some(platform.name().to_string());
state.parent = parent;
if !dry_run {
state.save(state_path)?;
let present =
surviving_interfaces(runner, platform, &created).map_err(|e| BringUpUnverified {
profile: profile.name.clone(),
reason: format!("{e:#}"),
})?;
let missing: Vec<String> = created
.iter()
.filter(|c| !present.contains(c))
.cloned()
.collect();
if !missing.is_empty() {
return Err(BringUpIncomplete {
profile: profile.name.clone(),
missing,
}
.into());
}
}
Ok(created)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BringUpIncomplete {
pub profile: String,
pub missing: Vec<String>,
}
impl std::fmt::Display for BringUpIncomplete {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let one = self.missing.len() == 1;
write!(
f,
"applied profile '{}', but {} not on this host afterward: {}. \
The commands reported success, so something removed or \
refused {} after creation",
self.profile,
if one {
"one interface is"
} else {
"some interfaces are"
},
self.missing.join(", "),
if one { "it" } else { "them" },
)
}
}
impl std::error::Error for BringUpIncomplete {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TeardownIncomplete {
pub profile: Option<String>,
pub survivors: Vec<String>,
}
impl std::fmt::Display for TeardownIncomplete {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let one = self.survivors.len() == 1;
write!(
f,
"tore down '{}', but {} still present on this host: {}. \
Something outside vlanctl is holding {} up — a connection \
manager with a profile for {} will re-create {} as fast as it \
is removed",
self.profile.as_deref().unwrap_or("(unnamed)"),
if one {
"one interface is"
} else {
"some interfaces are"
},
self.survivors.join(", "),
if one { "it" } else { "them" },
if one { "that name" } else { "those names" },
if one { "it" } else { "them" },
)
}
}
impl std::error::Error for TeardownIncomplete {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BringUpUnverified {
pub profile: String,
pub reason: String,
}
impl std::fmt::Display for BringUpUnverified {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"applied profile '{}', but could not list this host's interfaces \
afterward to confirm it ({})",
self.profile, self.reason
)
}
}
impl std::error::Error for BringUpUnverified {}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TeardownUnverified {
pub profile: Option<String>,
pub reason: String,
}
impl std::fmt::Display for TeardownUnverified {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"tore down '{}', but could not list this host's interfaces \
afterward to confirm it ({})",
self.profile.as_deref().unwrap_or("(unnamed)"),
self.reason
)
}
}
impl std::error::Error for TeardownUnverified {}
fn rollback<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
created: &[String],
parent: Option<&ParentConfig>,
) {
for iface in created.iter().rev() {
for cmd in platform.teardown_commands(iface) {
let _ = runner.run(&cmd);
}
}
if let Some(parent) = parent {
for cmd in platform.parent_restore_commands(parent) {
let _ = runner.run(&cmd);
}
}
}
pub fn down<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
state_path: &Path,
dry_run: bool,
) -> Result<()> {
let state = State::load(state_path)?;
let live = platform.list_devices(runner)?;
for iface in state.interfaces.iter().rev() {
if !live.contains(iface) {
continue;
}
for cmd in platform.teardown_commands(iface) {
runner.run(&cmd)?;
}
}
if !dry_run && platform.teardown_removes_interface() {
let survivors = surviving_interfaces(runner, platform, &state.interfaces).map_err(|e| {
TeardownUnverified {
profile: state.active_profile.clone(),
reason: format!("{e:#}"),
}
})?;
if !survivors.is_empty() {
return Err(TeardownIncomplete {
profile: state.active_profile.clone(),
survivors,
}
.into());
}
}
if let Some(parent) = &state.parent {
for cmd in platform.parent_restore_commands(parent) {
runner.run(&cmd)?;
}
}
if !dry_run {
State::default().save(state_path)?;
}
Ok(())
}
fn surviving_interfaces<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
interfaces: &[String],
) -> Result<Vec<String>> {
let live = platform.list_devices(runner)?;
Ok(interfaces
.iter()
.filter(|name| live.contains(name))
.cloned()
.collect())
}
pub fn show_plan(platform: &dyn Platform, profile: &Profile, device: &str) -> Vec<String> {
profile
.interfaces
.iter()
.flat_map(|interface| bringup_commands_for(platform, interface, device))
.map(|cmd| cmd.display())
.collect()
}
pub fn list_profiles(dir: &Path) -> Result<Vec<String>> {
let mut names = Vec::new();
if !dir.exists() {
return Ok(names);
}
for entry in std::fs::read_dir(dir).with_context(|| format!("reading {}", dir.display()))? {
let path = entry?.path();
if path.extension().and_then(|e| e.to_str()) == Some("toml")
&& let Some(stem) = path.file_stem().and_then(|s| s.to_str())
{
names.push(stem.to_string());
}
}
names.sort();
Ok(names)
}
pub fn status<R: CommandRunner>(
runner: &mut R,
platform: &dyn Platform,
state_path: &Path,
) -> Result<String> {
let state = State::load(state_path)?;
let live = platform.list_devices(runner)?;
let mut report = String::new();
match &state.active_profile {
None => report.push_str("No active profile.\n"),
Some(name) => {
report.push_str(&format!("Active profile: {name}\n"));
for iface in &state.interfaces {
let present = if live.contains(iface) {
"up"
} else {
"MISSING"
};
report.push_str(&format!(" {iface}: {present}\n"));
}
}
}
Ok(report)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::net::RecordingRunner;
use crate::plan::{Linux, MacOs, WindowsDriverVlan, WindowsHyperV};
fn profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"t\"\ndevice=\"en0\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n\
[[interface]]\nvlan=200\naddress=\"10.0.0.5/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn untagged_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"halo\"\ndevice=\"en0\"\n\
[[interface]]\naddress=\"192.168.1.100/24\"\n\
[[interface.route]]\ndestination=\"192.168.10.151/32\"\n\
[[interface]]\nvlan=12\naddress=\"192.168.10.1/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn runner_with_device() -> RecordingRunner {
let mut r = RecordingRunner::default();
r.stdout_queue.insert(
"ifconfig -l".to_string(),
["lo0 en0"].into_iter().map(String::from).collect(),
);
r.stdout.insert(
"ifconfig -l".to_string(),
"lo0 en0 vlan100 vlan200".to_string(),
);
r
}
fn linux_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"t\"\ndevice=\"eth0\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n\
[[interface]]\nvlan=200\naddress=\"10.0.0.5/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn linux_runner(live: &str) -> RecordingRunner {
let mut r = RecordingRunner::default();
let json = format!(
"[{}]",
live.split_whitespace()
.map(|n| format!(r#"{{"ifname":"{n}"}}"#))
.collect::<Vec<_>>()
.join(",")
);
r.stdout_queue.insert(
"ip -json link show".to_string(),
[json.clone()].into_iter().collect(),
);
let after = format!(
"[{}]",
live.split_whitespace()
.chain(["eth0.100", "eth0.200"])
.map(|n| format!(r#"{{"ifname":"{n}"}}"#))
.collect::<Vec<_>>()
.join(",")
);
r.stdout.insert("ip -json link show".to_string(), after);
r.stdout
.insert("ip -d -json link show".to_string(), "[]".to_string());
r
}
#[test]
fn apply_with_linux_records_what_ip_link_add_created() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-ok.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
let created = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap();
assert_eq!(created, vec!["eth0.100", "eth0.200"]);
let state = State::load(&state_path).unwrap();
assert_eq!(state.active_profile.as_deref(), Some("t"));
assert_eq!(state.interfaces, vec!["eth0.100", "eth0.200"]);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn apply_reports_interfaces_that_never_appeared() {
let state_path = std::env::temp_dir().join("vlanctl-apply-missing.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
r.stdout.insert(
"ip -json link show".to_string(),
r#"[{"ifname":"lo"},{"ifname":"eth0"}]"#.to_string(),
);
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false)
.expect_err("interfaces that never appeared are not a successful apply");
let text = err.to_string();
assert!(
text.contains("eth0.100"),
"the missing interface must be named: {text}"
);
let typed = err
.downcast_ref::<BringUpIncomplete>()
.expect("a failed verification is a BringUpIncomplete");
assert_eq!(typed.profile, "t");
assert_eq!(typed.missing, vec!["eth0.100", "eth0.200"]);
assert_eq!(
State::load(&state_path).unwrap().active_profile.as_deref(),
Some("t")
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_whose_host_cannot_be_listed_afterward_is_unverified() {
let state_path = std::env::temp_dir().join("vlanctl-apply-unverified.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
r.stdout
.insert("ip -json link show".to_string(), "not json".to_string());
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false)
.expect_err("an unconfirmed apply is not a success");
let typed = err
.downcast_ref::<BringUpUnverified>()
.unwrap_or_else(|| panic!("expected BringUpUnverified; got {err:#}"));
assert_eq!(typed.profile, "t");
assert_eq!(
State::load(&state_path).unwrap().active_profile.as_deref(),
Some("t"),
"the state is saved so `down` can clean up"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn down_whose_host_cannot_be_listed_afterward_is_unverified() {
let state_path = std::env::temp_dir().join("vlanctl-down-unverified.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["eth0.100".to_string()],
backend: None,
parent: None,
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout_queue.insert(
"ip -json link show".to_string(),
[r#"[{"ifname":"eth0"},{"ifname":"eth0.100"}]"#.to_string()]
.into_iter()
.collect(),
);
r.stdout
.insert("ip -json link show".to_string(), "not json".to_string());
let err = down(&mut r, &Linux, &state_path, false)
.expect_err("an unconfirmed teardown is not a clean one");
assert_eq!(
err.downcast_ref::<TeardownUnverified>()
.map(|t| t.profile.as_deref()),
Some(Some("t")),
"expected TeardownUnverified; got {err:#}"
);
assert!(
r.commands
.iter()
.any(|c| c.display().starts_with("ip link del")),
"the teardown itself must have run"
);
assert_eq!(
State::load(&state_path).unwrap().interfaces,
vec!["eth0.100".to_string()],
"state survives an unconfirmed teardown"
);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn apply_with_linux_rolls_back_with_ip_link_del() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-fail.json");
let _ = std::fs::remove_file(&state_path);
let mut probe = linux_runner("lo eth0");
apply(
&mut probe,
&Linux,
&linux_profile(),
None,
&state_path,
true,
)
.unwrap();
let fail_at = probe
.commands
.iter()
.position(|c| {
c.display()
.starts_with("ip link add link eth0 name eth0.200 ")
})
.expect("the plan creates eth0.200");
let mut r = linux_runner("lo eth0");
r.fail_at = Some(fail_at);
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("rolled back"), "{err}");
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"ip link del eth0.100".to_string()),
"rollback must delete the sub-interface it created: {rendered:?}"
);
assert!(!rendered.contains(&"ip link del eth0.200".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
fn windows_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"lab\"\ndevice=\"Ethernet 2\"\n\
[[interface]]\naddress=\"192.168.1.100/24\"\n\
[[interface.route]]\ndestination=\"192.168.10.151/32\"\n\
[[interface]]\nvlan=12\naddress=\"192.168.10.1/24\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
fn windows_runner(live: &[&str]) -> RecordingRunner {
let mut r = RecordingRunner::default();
r.stdout.insert(windows_list_probe(), live.join("\r\n"));
r
}
fn windows_runner_changing(before: &[&str], after: &[&str]) -> RecordingRunner {
let mut r = windows_runner(after);
r.stdout_queue
.insert(windows_list_probe(), [before.join("\r\n")].into());
r
}
fn windows_list_probe() -> String {
let mut probe = RecordingRunner::default();
WindowsHyperV.list_devices(&mut probe).unwrap();
probe.commands[0].display()
}
#[test]
fn apply_with_windows_records_the_untagged_adapter_and_down_removes_it() {
let state_path = std::env::temp_dir().join("vlanctl-windows-apply-ok.json");
let _ = std::fs::remove_file(&state_path);
let mut r = windows_runner_changing(
&["Ethernet 2", "Wi-Fi"],
&[
"Ethernet 2",
"Wi-Fi",
"vEthernet (untagged)",
"vEthernet (vlan12)",
],
);
let created = apply(
&mut r,
&WindowsHyperV,
&windows_profile(),
None,
&state_path,
false,
)
.unwrap();
assert_eq!(created, vec!["vEthernet (untagged)", "vEthernet (vlan12)"]);
let state = State::load(&state_path).unwrap();
assert_eq!(state.interfaces, created);
let mut r = windows_runner_changing(
&["Ethernet 2", "vEthernet (untagged)", "vEthernet (vlan12)"],
&["Ethernet 2"],
);
down(&mut r, &WindowsHyperV, &state_path, false).unwrap();
let teardowns: Vec<&str> = r
.commands
.iter()
.filter(|c| WindowsHyperV.teardown_commands("x")[0].program == c.program)
.filter_map(|c| c.args.last())
.filter(|s| s.contains("Remove-VMNetworkAdapter"))
.map(String::as_str)
.collect();
assert_eq!(teardowns.len(), 2, "{teardowns:?}");
assert!(teardowns[0].contains("-Name 'vlan12'"), "{}", teardowns[0]);
assert!(
teardowns[1].contains("-Name 'untagged'"),
"{}",
teardowns[1]
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
fn windows_parent_probe() -> String {
let mut probe = RecordingRunner::default();
WindowsHyperV
.parent_snapshot(&mut probe, "Ethernet 2")
.unwrap();
probe.commands[0].display()
}
#[test]
fn apply_with_windows_records_the_parents_addressing_and_down_puts_it_back() {
let state_path = std::env::temp_dir().join("vlanctl-windows-parent-restore.json");
let _ = std::fs::remove_file(&state_path);
let mut r = windows_runner_changing(
&["Ethernet 2", "Wi-Fi"],
&[
"Ethernet 2",
"Wi-Fi",
"vEthernet (untagged)",
"vEthernet (vlan12)",
],
);
r.stdout.insert(
windows_parent_probe(),
"dhcp Disabled\r\naddress 192.168.11.87/24\r\n".to_string(),
);
apply(
&mut r,
&WindowsHyperV,
&windows_profile(),
None,
&state_path,
false,
)
.unwrap();
let state = State::load(&state_path).unwrap();
let parent = state.parent.expect("the parent's addressing is recorded");
assert_eq!(parent.device, "Ethernet 2");
assert!(!parent.dhcp);
assert_eq!(
parent.addresses,
vec!["192.168.11.87/24".parse::<IpNet>().unwrap()]
);
let mut r = windows_runner_changing(
&["Ethernet 2", "vEthernet (untagged)", "vEthernet (vlan12)"],
&["Ethernet 2"],
);
down(&mut r, &WindowsHyperV, &state_path, false).unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
let restore = rendered
.iter()
.position(|c| {
c == "netsh interface ipv4 set address Ethernet 2 static 192.168.11.87 \
255.255.255.0"
})
.unwrap_or_else(|| panic!("the parent's address is put back: {rendered:?}"));
let last_teardown = rendered
.iter()
.rposition(|c| c.contains("Remove-VMNetworkAdapter"))
.unwrap();
assert!(
last_teardown < restore,
"the parent is restored only after its last adapter is gone: {rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn a_failed_windows_apply_puts_the_parents_addressing_back_too() {
let state_path = std::env::temp_dir().join("vlanctl-windows-parent-rollback.json");
let _ = std::fs::remove_file(&state_path);
let mut probe = windows_runner(&["Ethernet 2", "Wi-Fi"]);
apply(
&mut probe,
&WindowsHyperV,
&windows_profile(),
None,
&state_path,
true,
)
.unwrap();
let fail_at = probe
.commands
.iter()
.position(|c| WindowsHyperV.records_created_interface(c))
.expect("the plan creates an adapter");
let mut r = windows_runner(&["Ethernet 2", "Wi-Fi"]);
r.stdout
.insert(windows_parent_probe(), "dhcp Enabled\r\n".to_string());
r.fail_at = Some(fail_at);
let err = apply(
&mut r,
&WindowsHyperV,
&windows_profile(),
None,
&state_path,
false,
)
.unwrap_err();
assert!(err.to_string().contains("rolled back"), "{err}");
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"netsh interface ipv4 set address Ethernet 2 dhcp".to_string()),
"{rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_windows_guards_the_untagged_adapter_too() {
let state_path = std::env::temp_dir().join("vlanctl-windows-apply-guard.json");
let _ = std::fs::remove_file(&state_path);
let mut r = windows_runner(&["Ethernet 2", "vEthernet (untagged)"]);
let err = apply(
&mut r,
&WindowsHyperV,
&windows_profile(),
None,
&state_path,
false,
)
.unwrap_err();
assert!(
err.to_string()
.contains("vEthernet (untagged) already exists"),
"{err}"
);
assert!(
!r.commands
.iter()
.any(|c| WindowsHyperV.records_created_interface(c)),
"nothing may be created after a refusal"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_records_the_backend_that_applied() {
let state_path = std::env::temp_dir().join("vlanctl-backend-recorded.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap();
assert_eq!(
State::load(&state_path).unwrap().backend.as_deref(),
Some("linux")
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_the_driver_vlan_backend_records_the_parent_and_down_puts_it_back() {
let p: Profile = toml::from_str(
"name=\"live\"\ndevice=\"Ethernet 2\"\n\
[[interface]]\nvlan=11\naddress=\"192.168.11.87/24\"\n",
)
.unwrap();
p.validate().unwrap();
let state_path = std::env::temp_dir().join("vlanctl-driver-vlan-apply.json");
let _ = std::fs::remove_file(&state_path);
let mut r = windows_runner(&["Ethernet 2", "Wi-Fi"]);
let created = apply(&mut r, &WindowsDriverVlan, &p, None, &state_path, false).unwrap();
assert_eq!(created, vec!["Ethernet 2"]);
let state = State::load(&state_path).unwrap();
assert_eq!(state.backend.as_deref(), Some("windows-driver-vlan"));
let mut r = windows_runner(&["Ethernet 2", "Wi-Fi"]);
down(&mut r, &WindowsDriverVlan, &state_path, false).unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"netsh interface ipv4 set address Ethernet 2 dhcp".to_string()),
"{rendered:?}"
);
assert!(
rendered
.iter()
.any(|c| c.contains("-RegistryKeyword 'VlanID' -RegistryValue '0'")),
"{rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_tears_the_previous_profile_down_through_the_backend_that_applied_it() {
let state_path = std::env::temp_dir().join("vlanctl-cross-backend-teardown.json");
State {
active_profile: Some("lab".to_string()),
interfaces: vec!["vEthernet (vlan11)".to_string()],
backend: Some("windows-hyperv".to_string()),
parent: None,
}
.save(&state_path)
.unwrap();
let live: Profile = toml::from_str(
"name=\"live\"\ndevice=\"Ethernet 2\"\n\
[[interface]]\nvlan=11\naddress=\"192.168.11.87/24\"\n",
)
.unwrap();
let mut r = windows_runner_changing(&["Ethernet 2", "vEthernet (vlan11)"], &["Ethernet 2"]);
apply(&mut r, &WindowsDriverVlan, &live, None, &state_path, false).unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered
.iter()
.any(|c| c.contains("Remove-VMNetworkAdapter -ManagementOS -Name 'vlan11'")),
"the switch's adapter must be removed through the Hyper-V backend: {rendered:?}"
);
assert!(
!rendered
.iter()
.any(|c| c.contains("set address vEthernet (vlan11) dhcp")),
"the driver backend's teardown must not touch the virtual adapter: {rendered:?}"
);
let state = State::load(&state_path).unwrap();
assert_eq!(state.backend.as_deref(), Some("windows-driver-vlan"));
assert_eq!(state.interfaces, vec!["Ethernet 2"]);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn a_backend_refusal_leaves_the_active_profile_standing() {
let state_path = std::env::temp_dir().join("vlanctl-refusal-keeps-active.json");
let active = State {
active_profile: Some("live".to_string()),
interfaces: vec!["Ethernet 2".to_string()],
backend: Some("windows-driver-vlan".to_string()),
parent: None,
};
active.save(&state_path).unwrap();
let mut r = windows_runner(&["Ethernet 2"]);
let err = apply(
&mut r,
&WindowsDriverVlan,
&windows_profile(),
None,
&state_path,
false,
)
.unwrap_err();
assert!(err.to_string().contains("one VLAN per adapter"), "{err}");
assert!(r.commands.is_empty(), "nothing may run: {:?}", r.commands);
assert_eq!(State::load(&state_path).unwrap(), active);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_linux_refuses_an_existing_sub_interface() {
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0 eth0.100");
let err = apply(&mut r, &Linux, &linux_profile(), None, &state_path, false).unwrap_err();
assert!(
err.to_string().contains("eth0.100 already exists"),
"expected the guard to refuse eth0.100: {err}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"{rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_refuses_a_vlan_id_already_taken_under_another_name() {
let state_path = std::env::temp_dir().join("vlanctl-vlan-id-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0 vlan100");
r.stdout.insert(
"ip -d -json link show".to_string(),
r#"[{"ifname":"vlan100","link":"eth0",
"linkinfo":{"info_kind":"vlan","info_data":{"id":100}}}]"#
.to_string(),
);
let err = apply(
&mut r,
&Linux,
&linux_profile(),
Some("eth0"),
&state_path,
false,
)
.unwrap_err();
let msg = err.to_string();
assert!(
msg.contains("vlan id 100") && msg.contains("vlan100") && msg.contains("eth0"),
"the refusal must name the id, the device holding it, and the parent: {msg}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"it must refuse BEFORE creating anything: {rendered:?}"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn the_cli_device_override_beats_the_profile_field() {
let mut p = linux_profile();
p.device = Some("en7".to_string());
let state_path = std::env::temp_dir().join("vlanctl-device-override.json");
let _ = std::fs::remove_file(&state_path);
let mut r = linux_runner("lo eth0");
let created = apply(&mut r, &Linux, &p, Some("eth0"), &state_path, true).unwrap();
assert!(
created.iter().all(|c| !c.contains("en7")),
"the profile's en7 must not appear: {created:?}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered
.iter()
.any(|c| c.contains("dev eth0") || c.contains("link eth0")),
"expected the override device to be used: {rendered:?}"
);
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_with_linux_guards_the_auto_detected_device_not_the_profile_field() {
let p: Profile = toml::from_str(
"name=\"t\"\n\
[[interface]]\nvlan=100\naddress=\"192.168.10.2/24\"\n",
)
.unwrap();
p.validate().unwrap();
assert!(p.device.is_none(), "this test exercises auto-detect");
let state_path = std::env::temp_dir().join("vlanctl-linux-apply-autodetect-guard.json");
let _ = std::fs::remove_file(&state_path);
let mut r = RecordingRunner::default();
r.stdout.insert(
"ip -json link show".to_string(),
r#"[{"ifname":"lo"},{"ifname":"eth0"},{"ifname":"eth0.100"}]"#.to_string(),
);
r.stdout.insert(
"ls /sys/class/net/eth0".to_string(),
"carrier operstate".to_string(),
);
r.stdout.insert(
"cat /sys/class/net/eth0/carrier".to_string(),
"1\n".to_string(),
);
let err = apply(&mut r, &Linux, &p, None, &state_path, false).unwrap_err();
assert!(
err.to_string().contains("eth0.100 already exists"),
"expected the guard to refuse the resolved device's sub-interface: {err}"
);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(&"ip -json link show".to_string())
&& rendered.contains(&"cat /sys/class/net/eth0/carrier".to_string()),
"auto-detect must actually have run: {rendered:?}"
);
assert!(
!rendered.iter().any(|c| c.contains("link add")),
"nothing may be created past a refused guard: {rendered:?}"
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn hex_netmask_prefix_for_contiguous_masks() {
assert_eq!(prefix_from_hex_netmask("0xffffff00"), Some(24));
assert_eq!(prefix_from_hex_netmask("0xffff0000"), Some(16));
assert_eq!(prefix_from_hex_netmask("0x00000000"), Some(0));
assert_eq!(prefix_from_hex_netmask("0xffffffff"), Some(32));
}
#[test]
fn hex_netmask_prefix_is_none_for_a_non_contiguous_mask() {
assert_eq!(prefix_from_hex_netmask("0xff00ff00"), None);
}
#[test]
fn hex_netmask_prefix_is_none_for_malformed_input() {
assert_eq!(prefix_from_hex_netmask("255.255.255.0"), None);
assert_eq!(prefix_from_hex_netmask(""), None);
}
#[test]
fn apply_uses_the_platform_for_bringup() {
let state_path = std::env::temp_dir().join("vlanctl-apply-uses-platform.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
apply(&mut r, &MacOs, &profile(), None, &state_path, true).expect("dry-run apply succeeds");
assert!(
r.commands
.iter()
.any(|c| c.display().starts_with("ifconfig vlan")),
"recorded: {:?}",
r.commands
);
}
#[test]
fn apply_creates_all_vlans_and_records_state() {
let state_path = std::env::temp_dir().join("vlanctl-apply-ok.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
let created = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap();
assert_eq!(created, vec!["vlan100", "vlan200"]);
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan100 create".to_string()));
assert!(rendered.contains(&"ifconfig vlan100 vlan 100 vlandev en0".to_string()));
assert!(rendered.contains(&"ifconfig vlan200 create".to_string()));
assert!(rendered.contains(&"ifconfig vlan200 vlan 200 vlandev en0".to_string()));
let state = State::load(&state_path).unwrap();
assert_eq!(state.active_profile.as_deref(), Some("t"));
assert_eq!(state.interfaces, vec!["vlan100", "vlan200"]);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn apply_rolls_back_on_failure() {
let state_path = std::env::temp_dir().join("vlanctl-apply-fail.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
r.fail_at = Some(4);
let err = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("rolled back"));
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan100 destroy".to_string()));
assert!(!rendered.contains(&"ifconfig vlan200 destroy".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn down_destroys_recorded_interfaces() {
let state_path = std::env::temp_dir().join("vlanctl-down.json");
let state = State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan0".to_string(), "vlan1".to_string()],
backend: None,
parent: None,
};
state.save(&state_path).unwrap();
let mut r = RecordingRunner::default();
r.stdout_queue.insert(
"ifconfig -l".to_string(),
["lo0 en0 vlan0 vlan1", "lo0 en0"]
.into_iter()
.map(String::from)
.collect(),
);
down(&mut r, &MacOs, &state_path, false).unwrap();
let rendered: Vec<String> = r
.commands
.iter()
.map(|c| c.display())
.filter(|c| c != "ifconfig -l")
.collect();
assert_eq!(
rendered,
vec!["ifconfig vlan1 destroy", "ifconfig vlan0 destroy"]
);
assert_eq!(State::load(&state_path).unwrap(), State::default());
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn down_skips_interfaces_no_longer_live() {
let state_path = std::env::temp_dir().join("vlanctl-down-reboot.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan10".to_string(), "vlan11".to_string()],
backend: None,
parent: None,
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout_queue.insert(
"ifconfig -l".to_string(),
["lo0 en0 vlan10", "lo0 en0"]
.into_iter()
.map(String::from)
.collect(),
);
down(&mut r, &MacOs, &state_path, false).unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"ifconfig vlan10 destroy".to_string()));
assert!(!rendered.contains(&"ifconfig vlan11 destroy".to_string()));
assert_eq!(State::load(&state_path).unwrap(), State::default());
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn down_reports_interfaces_that_survive_teardown() {
let state_path = std::env::temp_dir().join("vlanctl-down-survivor.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan10".to_string()],
backend: None,
parent: None,
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan10".to_string());
let err = down(&mut r, &MacOs, &state_path, false)
.expect_err("a surviving interface is not a clean teardown");
let text = err.to_string();
assert!(
text.contains("vlan10"),
"the survivor must be named: {text}"
);
assert_eq!(
err.downcast_ref::<TeardownIncomplete>(),
Some(&TeardownIncomplete {
profile: Some("t".to_string()),
survivors: vec!["vlan10".to_string()],
}),
"a failed teardown is a TeardownIncomplete carrying the survivors"
);
assert_eq!(
State::load(&state_path).unwrap().interfaces,
vec!["vlan10".to_string()],
"state must survive a teardown that did not finish"
);
std::fs::remove_file(&state_path).unwrap();
}
#[test]
fn show_plan_lists_commands() {
let lines = show_plan(&MacOs, &profile(), "en0");
assert_eq!(lines[0], "ifconfig vlan100 create");
assert_eq!(lines[1], "ifconfig vlan100 vlan 100 vlandev en0");
}
#[test]
fn apply_errors_if_interface_already_exists() {
let state_path = std::env::temp_dir().join("vlanctl-apply-collision.json");
let _ = std::fs::remove_file(&state_path);
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan100".to_string());
let err = apply(&mut r, &MacOs, &profile(), None, &state_path, false).unwrap_err();
assert!(err.to_string().contains("already exists"));
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(!rendered.iter().any(|c| c.contains("create")));
assert_eq!(State::load(&state_path).unwrap(), State::default());
let _ = std::fs::remove_file(&state_path);
}
#[test]
fn apply_untagged_configures_parent_and_records_only_vlan() {
let state_path = std::env::temp_dir().join("vlanctl-apply-untagged.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan12".to_string()); let created = apply(
&mut r,
&MacOs,
&untagged_profile(),
None,
&state_path,
false,
)
.unwrap();
assert_eq!(created, vec!["vlan12"]); let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(
rendered.contains(
&"ifconfig en0 inet 192.168.1.100 netmask 255.255.255.0 alias".to_string()
)
);
assert!(rendered.contains(&"route add -host 192.168.10.151 -interface en0".to_string()));
assert!(rendered.contains(&"ifconfig vlan12 create".to_string()));
}
#[test]
fn apply_untagged_skips_when_alias_already_present() {
let state_path = std::env::temp_dir().join("vlanctl-apply-untagged-idem.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan12".to_string());
r.stdout.insert(
"ifconfig en0".to_string(),
"\tinet 192.168.1.100 netmask 0xffffff00 broadcast 192.168.1.255".to_string(),
);
apply(
&mut r,
&MacOs,
&untagged_profile(),
None,
&state_path,
false,
)
.unwrap();
let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(!rendered.iter().any(|c| c.contains("alias")));
assert!(
!rendered
.iter()
.any(|c| c.contains("route add -host 192.168.10.151"))
);
assert!(rendered.contains(&"ifconfig vlan12 create".to_string())); }
#[test]
fn list_profiles_finds_toml_stems() {
let dir = std::env::temp_dir().join("vlanctl-profiles-test");
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("a.toml"), "name=\"a\"").unwrap();
std::fs::write(dir.join("b.toml"), "name=\"b\"").unwrap();
std::fs::write(dir.join("notes.txt"), "x").unwrap();
let names = list_profiles(&dir).unwrap();
assert_eq!(names, vec!["a", "b"]);
std::fs::remove_dir_all(&dir).unwrap();
}
fn mac_profile() -> Profile {
let p: Profile = toml::from_str(
"name=\"halo\"\ndevice=\"en0\"\n\
[[interface]]\naddress=\"192.168.1.100/24\"\n\
[[interface.route]]\ndestination=\"192.168.10.151/32\"\nmac=\"00:00:5e:00:53:01\"\n",
)
.unwrap();
p.validate().unwrap();
p
}
#[test]
fn apply_mac_route_emits_static_arp_and_records_nothing() {
let state_path = std::env::temp_dir().join("vlanctl-apply-mac.json");
let _ = std::fs::remove_file(&state_path);
let mut r = runner_with_device();
let created = apply(&mut r, &MacOs, &mac_profile(), None, &state_path, false).unwrap();
assert!(created.is_empty()); let rendered: Vec<String> = r.commands.iter().map(|c| c.display()).collect();
assert!(rendered.contains(&"route add -host 192.168.10.151 -interface en0".to_string()));
assert!(rendered.contains(&"arp -s 192.168.10.151 00:00:5e:00:53:01".to_string()));
assert!(!rendered.iter().any(|c| c.starts_with("arp -d")));
}
#[test]
fn status_flags_missing_interface() {
let state_path = std::env::temp_dir().join("vlanctl-status.json");
State {
active_profile: Some("t".to_string()),
interfaces: vec!["vlan0".to_string(), "vlan9".to_string()],
backend: None,
parent: None,
}
.save(&state_path)
.unwrap();
let mut r = RecordingRunner::default();
r.stdout
.insert("ifconfig -l".to_string(), "lo0 en0 vlan0".to_string());
let report = status(&mut r, &MacOs, &state_path).unwrap();
assert!(report.contains("vlan0: up"));
assert!(report.contains("vlan9: MISSING"));
std::fs::remove_file(&state_path).unwrap();
}
}