use super::ip::{IpAllocator, IpPool};
use crate::atomic::{read_toml, write_toml_atomic};
use crate::error::{Error, Result};
use crate::manifest;
use ipnet::IpNet;
use serde::{Deserialize, Serialize};
use std::collections::{BTreeMap, HashMap};
use std::ffi::OsStr;
use std::fs;
use std::io::ErrorKind;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NetworkRecord {
pub name: String,
pub bridge: String,
pub subnet: String,
pub gateway: String,
#[serde(default = "default_backend_epair")]
pub backend: String,
#[serde(default)]
pub host_iface: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ResolvedNetwork {
pub name: String,
pub bridge: Option<String>,
pub subnet: IpNet,
pub gateway: IpAddr,
pub backend: String,
}
#[derive(Debug, Clone)]
pub struct NetworkStore {
root: PathBuf,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct NetworkLeaseRecord {
pub owner: String,
pub ip: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
struct NetworkLeaseFile {
leases: Vec<NetworkLeaseRecord>,
}
#[derive(Debug, Clone)]
pub struct NetworkLeaseStore {
root: PathBuf,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct VnetStateRecord {
pub owner: String,
pub network: Option<String>,
pub bridge: String,
pub host_interface: String,
pub jail_interface: String,
#[serde(default = "default_backend_epair")]
pub backend: String,
}
fn default_backend_epair() -> String {
"epair".to_string()
}
#[derive(Debug, Clone)]
pub struct VnetStateStore {
root: PathBuf,
}
impl NetworkStore {
pub fn from_config(config: Option<&manifest::BlackshipConfig>) -> Self {
Self {
root: manifest::data_root(config).join("networks"),
}
}
pub fn create(&self, record: &NetworkRecord) -> Result<()> {
validate_network_name(&record.name)?;
fs::create_dir_all(&self.root)
.map_err(|e| Error::Network(format!("Failed to create network state dir: {e}")))?;
let path = self.record_path(&record.name)?;
let content = toml::to_string(record)
.map_err(|e| Error::Network(format!("Failed to serialize network metadata: {e}")))?;
match fs::OpenOptions::new()
.write(true)
.create_new(true)
.open(&path)
{
Ok(mut file) => {
use std::io::Write;
file.write_all(content.as_bytes())
.map_err(|e| Error::Network(format!("Failed to write network metadata: {e}")))
}
Err(err) if err.kind() == ErrorKind::AlreadyExists => {
Err(Error::NetworkAlreadyExists(record.name.clone()))
}
Err(err) => Err(Error::Network(format!(
"Failed to create network metadata file: {err}"
))),
}
}
pub fn save(&self, record: &NetworkRecord) -> Result<()> {
validate_network_name(&record.name)?;
fs::create_dir_all(&self.root)
.map_err(|e| Error::Network(format!("Failed to create network state dir: {e}")))?;
let path = self.record_path(&record.name)?;
let content = toml::to_string(record)
.map_err(|e| Error::Network(format!("Failed to serialize network metadata: {e}")))?;
fs::write(&path, content)
.map_err(|e| Error::Network(format!("Failed to write network metadata: {e}")))
}
pub fn get(&self, name: &str) -> Result<Option<NetworkRecord>> {
let path = self.record_path(name)?;
if !path.exists() {
return Ok(None);
}
read_network_record(&path)
}
pub fn delete(&self, name: &str) -> Result<bool> {
let path = self.record_path(name)?;
if !path.exists() {
return Ok(false);
}
fs::remove_file(&path)
.map_err(|e| Error::Network(format!("Failed to remove network metadata: {e}")))?;
Ok(true)
}
pub fn list(&self) -> Result<Vec<NetworkRecord>> {
if !self.root.exists() {
return Ok(Vec::new());
}
let mut records = Vec::new();
let entries = fs::read_dir(&self.root)
.map_err(|e| Error::Network(format!("Failed to read network state dir: {e}")))?;
for entry in entries {
let entry =
entry.map_err(|e| Error::Network(format!("Failed to read network entry: {e}")))?;
let path = entry.path();
if path.extension() != Some(OsStr::new("toml")) {
continue;
}
if let Some(record) = read_network_record(&path)? {
records.push(record);
}
}
records.sort_by(|a, b| a.name.cmp(&b.name));
Ok(records)
}
fn record_path(&self, name: &str) -> Result<PathBuf> {
validate_network_name(name)?;
Ok(self.root.join(format!("{name}.toml")))
}
}
impl NetworkLeaseStore {
pub fn from_config(config: Option<&manifest::BlackshipConfig>) -> Self {
Self {
root: manifest::data_root(config).join("network-leases"),
}
}
pub fn list(&self, network: &str) -> Result<Vec<NetworkLeaseRecord>> {
validate_network_name(network)?;
let path = self.record_path(network);
if !path.exists() {
return Ok(Vec::new());
}
Ok(read_toml::<NetworkLeaseFile>(&path, "network lease metadata")?.leases)
}
fn lock_path(&self, network: &str) -> PathBuf {
self.root.join(format!("{network}.lock"))
}
pub fn record(&self, network: &str, owner: &str, ip: IpAddr) -> Result<()> {
validate_network_name(network)?;
let _guard = FileLock::acquire(&self.lock_path(network))?;
if owner.is_empty() {
return Err(Error::InvalidArgument(
"Network lease owner cannot be empty".into(),
));
}
fs::create_dir_all(&self.root)
.map_err(|e| Error::Network(format!("Failed to create network lease dir: {e}")))?;
let mut leases = self.list(network)?;
let ip_str = ip.to_string();
if let Some(existing) = leases
.iter()
.find(|lease| lease.owner != owner && lease.ip == ip_str)
{
return Err(Error::Network(format!(
"Address {} is already leased to '{}'",
existing.ip, existing.owner
)));
}
if let Some(existing) = leases.iter_mut().find(|lease| lease.owner == owner) {
existing.ip = ip_str;
} else {
leases.push(NetworkLeaseRecord {
owner: owner.to_string(),
ip: ip_str,
});
}
leases.sort_by(|a, b| a.owner.cmp(&b.owner));
write_toml_atomic(
&self.record_path(network),
&NetworkLeaseFile { leases },
"network lease metadata",
)
}
pub fn release(&self, network: &str, owner: &str) -> Result<bool> {
validate_network_name(network)?;
let _guard = FileLock::acquire(&self.lock_path(network))?;
let path = self.record_path(network);
if !path.exists() {
return Ok(false);
}
let mut leases = self.list(network)?;
let original_len = leases.len();
leases.retain(|lease| lease.owner != owner);
if leases.len() == original_len {
return Ok(false);
}
if leases.is_empty() {
fs::remove_file(&path).map_err(|e| {
Error::Network(format!(
"Failed to remove empty network lease metadata: {e}"
))
})?;
} else {
write_toml_atomic(
&path,
&NetworkLeaseFile { leases },
"network lease metadata",
)?;
}
Ok(true)
}
pub fn release_owner(&self, owner: &str) -> Result<Vec<(String, IpAddr)>> {
if !self.root.exists() {
return Ok(Vec::new());
}
let mut released = Vec::new();
let entries = fs::read_dir(&self.root)
.map_err(|e| Error::Network(format!("Failed to read network lease dir: {e}")))?;
for entry in entries {
let entry = entry
.map_err(|e| Error::Network(format!("Failed to read network lease entry: {e}")))?;
let path = entry.path();
if path.extension() != Some(OsStr::new("toml")) {
continue;
}
let Some(network_name) = path.file_stem().and_then(|stem| stem.to_str()) else {
continue;
};
let leases = self.list(network_name)?;
for lease in leases.iter().filter(|lease| lease.owner == owner) {
let ip = lease.ip.parse().map_err(|e| {
Error::Network(format!(
"Failed to parse leased IP '{}' for owner '{}': {}",
lease.ip, owner, e
))
})?;
released.push((network_name.to_string(), ip));
}
self.release(network_name, owner)?;
}
Ok(released)
}
fn record_path(&self, network: &str) -> PathBuf {
self.root.join(format!("{network}.toml"))
}
}
impl VnetStateStore {
pub fn from_config(config: Option<&manifest::BlackshipConfig>) -> Self {
Self {
root: manifest::data_root(config).join("vnet"),
}
}
pub fn save(&self, record: &VnetStateRecord) -> Result<()> {
Self::validate_owner(&record.owner)?;
fs::create_dir_all(&self.root)
.map_err(|e| Error::Network(format!("Failed to create VNET state dir: {e}")))?;
write_toml_atomic(
&self.record_path(&record.owner),
record,
"VNET state metadata",
)
}
pub fn get(&self, owner: &str) -> Result<Option<VnetStateRecord>> {
Self::validate_owner(owner)?;
let path = self.record_path(owner);
if !path.exists() {
return Ok(None);
}
read_toml::<VnetStateRecord>(&path, "VNET state metadata").map(Some)
}
pub fn delete(&self, owner: &str) -> Result<bool> {
Self::validate_owner(owner)?;
let path = self.record_path(owner);
if !path.exists() {
return Ok(false);
}
fs::remove_file(&path)
.map_err(|e| Error::Network(format!("Failed to remove VNET state metadata: {e}")))?;
Ok(true)
}
pub fn list(&self) -> Result<Vec<VnetStateRecord>> {
let entries = match fs::read_dir(&self.root) {
Ok(entries) => entries,
Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
Err(e) => {
return Err(Error::Network(format!(
"Failed to read VNET state dir: {e}"
)));
}
};
let mut records = Vec::new();
for entry in entries.flatten() {
let path = entry.path();
if path.extension() != Some(std::ffi::OsStr::new("toml")) {
continue;
}
match read_toml::<VnetStateRecord>(&path, "VNET state metadata") {
Ok(record) => records.push(record),
Err(e) => eprintln!(
"Warning: skipping VNET state record {}: {e}",
path.display()
),
}
}
records.sort_by(|a, b| a.owner.cmp(&b.owner));
Ok(records)
}
fn record_path(&self, owner: &str) -> PathBuf {
self.root.join(format!("{owner}.toml"))
}
fn validate_owner(owner: &str) -> Result<()> {
if owner.is_empty() {
return Err(Error::InvalidArgument(
"VNET state owner cannot be empty".into(),
));
}
if owner.contains('/') || owner.contains('\\') || owner.contains("..") {
return Err(Error::InvalidArgument(format!(
"VNET state owner '{owner}' contains invalid characters"
)));
}
Ok(())
}
}
pub fn load_runtime_networks(
config: Option<&manifest::BlackshipConfig>,
) -> Result<Vec<ResolvedNetwork>> {
let mut networks = BTreeMap::new();
if let Some(config) = config {
for network in &config.networks {
let subnet: IpNet = network.subnet.parse().map_err(|e| {
Error::Network(format!(
"Invalid subnet '{}' for network '{}': {}",
network.subnet, network.name, e
))
})?;
let gateway = if let Some(gateway) = network.gateway {
IpPool::with_gateway(subnet, gateway)?.gateway()
} else {
IpPool::new(subnet)?.gateway()
};
networks.insert(
network.name.clone(),
ResolvedNetwork {
name: network.name.clone(),
bridge: None,
subnet,
gateway,
backend: default_backend_epair(),
},
);
}
}
for record in NetworkStore::from_config(config).list()? {
let subnet: IpNet = record.subnet.parse().map_err(|e| {
Error::Network(format!(
"Invalid subnet '{}' for network '{}': {}",
record.subnet, record.name, e
))
})?;
let gateway: IpAddr = record.gateway.parse().map_err(|e| {
Error::Network(format!(
"Invalid gateway '{}' for network '{}': {}",
record.gateway, record.name, e
))
})?;
let bridge = Some(record.bridge.clone());
if let Some(existing) = networks.get_mut(&record.name) {
if existing.subnet != subnet || existing.gateway != gateway {
return Err(Error::Network(format!(
"Network '{}' is defined differently in config and runtime state",
record.name
)));
}
existing.bridge = bridge;
existing.backend.clone_from(&record.backend);
} else {
networks.insert(
record.name.clone(),
ResolvedNetwork {
name: record.name.clone(),
bridge,
subnet,
gateway,
backend: record.backend.clone(),
},
);
}
}
Ok(networks.into_values().collect())
}
pub fn load_runtime_network_map(
config: Option<&manifest::BlackshipConfig>,
) -> Result<HashMap<String, ResolvedNetwork>> {
let mut map = HashMap::new();
for network in load_runtime_networks(config)? {
map.insert(network.name.clone(), network);
}
Ok(map)
}
pub fn build_runtime_allocator(
config: Option<&manifest::BlackshipConfig>,
) -> Result<(
HashMap<String, ResolvedNetwork>,
IpAllocator,
NetworkLeaseStore,
)> {
let runtime_networks = load_runtime_network_map(config)?;
let lease_store = NetworkLeaseStore::from_config(config);
let mut allocator = IpAllocator::new();
for network in runtime_networks.values() {
let mut pool = IpPool::with_gateway(network.subnet, network.gateway)?;
for lease in lease_store.list(&network.name)? {
let ip: IpAddr = lease.ip.parse().map_err(|e| {
Error::Network(format!(
"Failed to parse leased IP '{}' for owner '{}': {}",
lease.ip, lease.owner, e
))
})?;
pool.allocate_specific(ip)?;
}
allocator.add_pool(network.name.clone(), pool);
}
if let Some(config) = config {
for jail in &config.jails {
let Some(network) = jail.network.as_ref() else {
continue;
};
let Some(static_ip) = network.ip else {
continue;
};
for network_name in &network.networks {
let Some(pool) = allocator.get_pool_mut(network_name) else {
continue;
};
pool.allocate_specific(static_ip)?;
}
}
}
Ok((runtime_networks, allocator, lease_store))
}
fn read_network_record(path: &Path) -> Result<Option<NetworkRecord>> {
read_toml::<NetworkRecord>(path, "network metadata").map(Some)
}
pub fn allocate_and_record(
allocator: &mut IpAllocator,
lease_store: &NetworkLeaseStore,
network: &str,
owner: &str,
) -> Result<IpAddr> {
for _ in 0..256 {
let ip = allocator.allocate(network)?;
match lease_store.record(network, owner, ip) {
Ok(()) => return Ok(ip),
Err(Error::Network(msg)) if msg.contains("already leased") => {}
Err(e) => return Err(e),
}
}
Err(Error::Network(format!(
"Could not claim a free address on network '{network}' after 256 attempts"
)))
}
pub struct FileLock {
file: fs::File,
}
impl FileLock {
pub fn acquire(path: &Path) -> Result<Self> {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent)
.map_err(|e| Error::Network(format!("Failed to create lock dir: {e}")))?;
}
let file = fs::OpenOptions::new()
.write(true)
.create(true)
.truncate(false)
.open(path)
.map_err(|e| Error::Network(format!("Failed to open lock file: {e}")))?;
file.lock()
.map_err(|e| Error::Network(format!("Failed to lock {}: {e}", path.display())))?;
Ok(Self { file })
}
}
impl Drop for FileLock {
fn drop(&mut self) {
let _ = self.file.unlock();
}
}
fn validate_network_name(name: &str) -> Result<()> {
if name.is_empty() {
return Err(Error::InvalidArgument(
"Network name cannot be empty".into(),
));
}
if !name
.chars()
.all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.'))
{
return Err(Error::InvalidArgument(format!(
"Invalid network name '{name}': use only letters, numbers, '.', '-' and '_'"
)));
}
Ok(())
}
#[cfg(test)]
mod tests;